The document discusses renaming features in Visual Studio 2015. It describes how VS2015 provides renaming assistance through suggestions from the light bulb icon and previews changes before renaming. The renaming window allows renaming variables, methods, properties, classes, parameters and strings. It can also rename code comments and detect conflicts if the new name already exists. Renaming occurs inline and on the fly. The examples demonstrate renaming a variable, method, and parameter across multiple files. VS2015 helps optimize code through intelligent and automated renaming.
The document discusses new and improved debugging features in Visual Studio 2015, including easier breakpoint configuration with an inline toolbar, simplified context menus, and settings windows that appear as peek windows. It also covers breakpoint conditions that allow hitting a breakpoint based on the number of hits or a conditional expression. Breakpoint actions allow logging messages to the output window. Additionally, the improved Error List in VS 2015 displays all errors at once, allows filtering by severity and error code, and links error codes to documentation.
The document discusses Visual Studio's live static code analysis feature. It explains that this feature analyzes code in real-time as it is written, without requiring compilation, to detect errors and potential issues based on installed code analyzers. The document demonstrates how to install and use code analyzers through examples, showing how analyzers detect issues and provide suggestions to fix problems directly in the code editor through light bulb notifications. It provides a case study walking through fixing various issues detected in sample code using suggestions from an analyzer to iteratively improve the code quality.
The document discusses various widgets in Android for building user interfaces, including TextView, EditText, Button, CheckBox, RadioButton, DatePicker, TimePicker, image buttons, text fields, toggle buttons, and a rating bar. It provides tutorials on how to create and handle events for these different form elements and widgets. The last part discusses how to create an autocomplete text view that provides country name suggestions from a string array.
Complete steps to Integrate Push Notification for Your Cocos2dx App with Push...ShepHertz
Integrating push notification for ios and android in cocos2dx is always a big challenge for developers. So, this blog will walk you through step-by-step integration process by taking the examples from the sample.
The document discusses various Android widgets such as TextView, ImageView, EditText, CheckBox, and RadioButton. It provides code examples for how to implement each widget in an Android application. For TextView, it demonstrates how to display simple text. For ImageView, it shows how to display an image. For EditText, it explains how to create an editable text field. For CheckBox, it provides an example of a checkbox that can be checked or unchecked. And for RadioButton, it discusses using radio buttons within a RadioGroup so that only one can be selected at a time.
The document discusses how to use Visual Studio tools to build Visual Basic applications, including identifying the interface elements like the title bar, menu bar, toolbox, and standard toolbar. It provides steps for opening a new project, creating a form, and adding controls like text boxes and buttons to the form while customizing properties like the text. The objectives are for students to become familiar with the Visual Studio interface and learn how to set up a basic project with a form and some example controls.
Visual Studio, Eclipse, and NetBeans are three popular IDEs. Visual Studio features include automatic indentation, side-by-side editing, IntelliSense, debugging tools, and reusable code snippets. Eclipse features include file encoding settings, automatic saving, type filters, launch configurations, and code formatting options. NetBeans provides a full-featured Java EE environment out of the box and strong support for HTML5, JavaScript, and CSS development.
The document discusses new and improved debugging features in Visual Studio 2015, including easier breakpoint configuration with an inline toolbar, simplified context menus, and settings windows that appear as peek windows. It also covers breakpoint conditions that allow hitting a breakpoint based on the number of hits or a conditional expression. Breakpoint actions allow logging messages to the output window. Additionally, the improved Error List in VS 2015 displays all errors at once, allows filtering by severity and error code, and links error codes to documentation.
The document discusses Visual Studio's live static code analysis feature. It explains that this feature analyzes code in real-time as it is written, without requiring compilation, to detect errors and potential issues based on installed code analyzers. The document demonstrates how to install and use code analyzers through examples, showing how analyzers detect issues and provide suggestions to fix problems directly in the code editor through light bulb notifications. It provides a case study walking through fixing various issues detected in sample code using suggestions from an analyzer to iteratively improve the code quality.
The document discusses various widgets in Android for building user interfaces, including TextView, EditText, Button, CheckBox, RadioButton, DatePicker, TimePicker, image buttons, text fields, toggle buttons, and a rating bar. It provides tutorials on how to create and handle events for these different form elements and widgets. The last part discusses how to create an autocomplete text view that provides country name suggestions from a string array.
Complete steps to Integrate Push Notification for Your Cocos2dx App with Push...ShepHertz
Integrating push notification for ios and android in cocos2dx is always a big challenge for developers. So, this blog will walk you through step-by-step integration process by taking the examples from the sample.
The document discusses various Android widgets such as TextView, ImageView, EditText, CheckBox, and RadioButton. It provides code examples for how to implement each widget in an Android application. For TextView, it demonstrates how to display simple text. For ImageView, it shows how to display an image. For EditText, it explains how to create an editable text field. For CheckBox, it provides an example of a checkbox that can be checked or unchecked. And for RadioButton, it discusses using radio buttons within a RadioGroup so that only one can be selected at a time.
The document discusses how to use Visual Studio tools to build Visual Basic applications, including identifying the interface elements like the title bar, menu bar, toolbox, and standard toolbar. It provides steps for opening a new project, creating a form, and adding controls like text boxes and buttons to the form while customizing properties like the text. The objectives are for students to become familiar with the Visual Studio interface and learn how to set up a basic project with a form and some example controls.
Visual Studio, Eclipse, and NetBeans are three popular IDEs. Visual Studio features include automatic indentation, side-by-side editing, IntelliSense, debugging tools, and reusable code snippets. Eclipse features include file encoding settings, automatic saving, type filters, launch configurations, and code formatting options. NetBeans provides a full-featured Java EE environment out of the box and strong support for HTML5, JavaScript, and CSS development.
Coded ui - lesson 3 - case study - calculatorOmer Karpas
This document discusses using the Coded UI framework to create automated tests for a calculator application. It describes recording actions in the calculator to create a test, such as entering 2 + 3 =. Assertions are then added to verify the expected result is displayed. The generated code for the recorded test and assertion is examined. Further lessons will explore the generated code in more depth.
This document provides instructions for creating a simple tasklist application using ASP.NET MVC. It describes creating the controller, views, database, and model. The controller contains actions for listing, creating, and completing tasks. Views are created for displaying the task list and creating new tasks. A database with a Tasks table is set up using LINQ to SQL. Logic is added to the controller actions to retrieve and save tasks from the database. The task list view is modified to display tasks from the model.
The document describes how to write functional test cases for SQL queries and web applications using JUnit in Java. It includes:
1) Creating a connection class to establish a connection to a MySQL database.
2) Defining classes containing methods that implement the functionality to be tested.
3) Writing JUnit test cases that call the functionality methods.
4) Using annotations like @Before, @Test, and @After for test initialization, execution, and teardown.
Android User Interface Tutorial: DatePicker, TimePicker & SpinnerAhsanul Karim
These slides are for self-learners and trainees of my BASIS and DIIT Android course.
I have used information, content and images from various sources. As these materials are for non-commercial use, I think they won’t infringe any copyright issue.
This document provides a tutorial on how to build a simple graphical user interface (GUI) calculator application using the NetBeans IDE. It explains how to create a project, build the front end by adding labels, text fields and buttons to a JFrame container, and add functionality by writing event handlers for the buttons. The finished application allows the user to enter two numbers, click an "Add" button to calculate the sum, and view the result in a text field. It also includes buttons to clear the fields and exit the program.
A comprehensive guide on developing responsive and common react filter componentKaty Slemon
A blog that will help you develop a responsive and common React Filter Component for both desktop and mobile views to maintain consistency across the UI.
The document provides instructions for creating an Android application to demonstrate the activity lifecycle and passing data between activities. It involves creating multiple activities and linking them together. The main activity displays buttons to launch a second activity, select a contact, and change the background color. Methods are added to each activity to log lifecycle events to the logcat. When changing color or selecting contact, data is passed back to the main activity using startActivityForResult and onActivityResult. This allows the main activity to update the UI based on the result from other activities.
The document discusses the code assistance features of Visual Studio 2015. It provides examples of how the light bulb icon displays potential fixes for syntax errors and missing code. It also shows how refactoring suggestions are provided to optimize code, such as removing unused namespaces or changing a method to directly return a value rather than using a temporary variable. The light bulb icon assists with code completion, error fixing, and refactoring to improve code quality and developer productivity.
The document provides information on how to become a Vaadin expert by attending official Vaadin trainings to learn best practices, application architecture, and new features. It recommends taking the Vaadin certification exam to boost your career and become a Vaadin Certified Developer. Additional steps suggested include developing skills by building Java web applications, reading documentation, and signing up for trainings and certification.
This document provides a tutorial on creating a custom widget in Rational Host Access Transformation Services (HATS). It describes how to create a custom HTML widget that renders an input field and button. The widget is designed to allow adding a button next to an input field to send a mnemonic keyword for a specific purpose, with the button name and keyword configurable via global variables or direct input. The tutorial covers creating the widget Java class, implementing its settings UI and drawHTML() method to generate the HTML output, and provides an example usage transforming an iSeries screen.
ActiveX is a framework for reusable software components that can be composed to provide application functionality. It was introduced by Microsoft in 1996 and is commonly used in Windows applications and allows components to be embedded in web pages. ActiveX controls can create distributed applications over the internet. They can provide more functionality than Java applets but only run on Internet Explorer and Windows. Malware has been spread using ActiveX controls installed from malicious websites.
The document describes creating new method content elements to add to an existing delivery process for a services oriented architecture (SOA) implementation. Specifically, it involves:
1. Creating a new plugin to contain the new elements, including a content package.
2. Creating a new work product called "Service Implementation" and categorizing it.
3. Adding responsibility for the new work product to the existing "Implementer" role.
4. Adding the new work product as an output to the existing "Implement Design Elements" task by creating a contributing task.
The goal is to enhance the existing delivery process with additional elements for SOA implementation while reusing existing elements where possible. The scenario will be
This document discusses code refactoring techniques in Visual Studio 2015, including inline temporary variables and introducing local variables. It provides an example C# class with a method to fetch products above a certain price, and shows how Visual Studio's code refactoring suggestions can optimize the method in multiple steps. These include removing temporary variables, converting the method to an expression-bodied member, and reducing the code to a single line. The document emphasizes that code refactoring requires an understanding of how the changes will affect the code.
Android User Interface: Basic Form WidgetsAhsanul Karim
This document provides a tutorial on creating various user interface elements in Android applications, including buttons, text fields, checkboxes, radio buttons, toggle buttons, rating bars, and auto-complete text views. It includes code examples for adding each element to an app layout and handling user interactions with them.
1. Create a test project for the Android application to be tested and add the Robotium JAR file to the project.
2. Create a test case class and write test methods to test the main functionality of the Android app by accessing its UI elements, entering sample input, clicking buttons, and asserting expected output.
3. Run the test case to launch the app in an emulator, automatically perform the test steps, and verify the test results.
Steps how to create active x using visual studio 2008Yudep Apoi
The document outlines 17 steps to create an ActiveX control in Visual Studio 2008 using C# that can be deployed via a CAB file and initialized from JavaScript. Key steps include:
1. Creating a class library project and interface to expose the control's methods.
2. Marking the control as safe for scripting by implementing the IObjectSafety interface.
3. Creating an MSI installer for the control.
4. Packaging the MSI into a CAB file for web deployment.
5. Testing initialization and methods of the control via a test ASP.NET page and JavaScript.
Visual studio ide componects dot net framworkDipen Parmar
The document describes the main components of the Visual Studio IDE. It discusses the various menus including File, Edit, View, Project, Build, Format, Data, Tools, Window, and Help. It also covers the main windows of the IDE like the Toolbox Window, Solution Explorer, Properties Window, Output Window, Command Window, and Task List Window.
The Coded UI Test Builder can be used to record manual tests and convert them into Coded UI tests. It also allows viewing of an application's control hierarchy and properties. The four buttons in the Coded UI Test Builder are Record, Show recorded steps, Crosshair, and Generate code. The Record button starts, stops, pauses, and resumes recording. Show recorded steps opens a window showing recorded actions. The Crosshair drags over controls to view properties and hierarchy. Generate code converts recorded actions to code.
An application for regression testing of the PVS-Studio and CppCat analyzers.
Implementing the mechanism of regression testing of the static code analyzers PVS-Studio and CppCat.
Ensuring that tests are run on a large number of open-source C/C++ projects.
Ensuring testing of the analyzers’ operation under all the supported Visual Studio versions.
Providing convenient handling of the differences list, quick view feature, apply changes feature, and so on.
The document describes how to use Mulesoft to connect a CSV file to a Salesforce account. It involves using a File connector to monitor an input folder for CSV files. A Salesforce connector is configured with a username, password and security token. A DataMapper transformer maps the CSV file fields to Salesforce object fields. When run, the application will take CSV contact data from the input folder and upload it to the Salesforce account as new contacts.
This document discusses the purpose of universities through a series of reflective activities and discussions. It begins with questioning what universities are for from both an individual and societal perspective. Participants then engage in individual reflection, group discussions to build consensus, and visual art activities to explore different conceptions of the purpose of higher education. Key purposes that emerge include personal growth, citizenship, social justice, knowledge and intellectual growth, character development, creativity, and understanding one's role in the world. The document concludes by reflecting on universities cultivating educated and virtuous individuals but leaves the overarching question of the purpose of higher education open-ended.
This document discusses content negotiation in ASP.NET Web API 2. It explains what content negotiation is, why it is important, and how to implement it in Web API. Content negotiation allows a client to specify the desired response format using request headers like Accept and Content-Type. Web API uses formatters to serialize the response into the requested format. The document provides examples of configuring formatters to support different media types and customize the JSON output. It also describes how the content negotiation pipeline in Web API works to select the appropriate formatter based on the request headers.
Coded ui - lesson 3 - case study - calculatorOmer Karpas
This document discusses using the Coded UI framework to create automated tests for a calculator application. It describes recording actions in the calculator to create a test, such as entering 2 + 3 =. Assertions are then added to verify the expected result is displayed. The generated code for the recorded test and assertion is examined. Further lessons will explore the generated code in more depth.
This document provides instructions for creating a simple tasklist application using ASP.NET MVC. It describes creating the controller, views, database, and model. The controller contains actions for listing, creating, and completing tasks. Views are created for displaying the task list and creating new tasks. A database with a Tasks table is set up using LINQ to SQL. Logic is added to the controller actions to retrieve and save tasks from the database. The task list view is modified to display tasks from the model.
The document describes how to write functional test cases for SQL queries and web applications using JUnit in Java. It includes:
1) Creating a connection class to establish a connection to a MySQL database.
2) Defining classes containing methods that implement the functionality to be tested.
3) Writing JUnit test cases that call the functionality methods.
4) Using annotations like @Before, @Test, and @After for test initialization, execution, and teardown.
Android User Interface Tutorial: DatePicker, TimePicker & SpinnerAhsanul Karim
These slides are for self-learners and trainees of my BASIS and DIIT Android course.
I have used information, content and images from various sources. As these materials are for non-commercial use, I think they won’t infringe any copyright issue.
This document provides a tutorial on how to build a simple graphical user interface (GUI) calculator application using the NetBeans IDE. It explains how to create a project, build the front end by adding labels, text fields and buttons to a JFrame container, and add functionality by writing event handlers for the buttons. The finished application allows the user to enter two numbers, click an "Add" button to calculate the sum, and view the result in a text field. It also includes buttons to clear the fields and exit the program.
A comprehensive guide on developing responsive and common react filter componentKaty Slemon
A blog that will help you develop a responsive and common React Filter Component for both desktop and mobile views to maintain consistency across the UI.
The document provides instructions for creating an Android application to demonstrate the activity lifecycle and passing data between activities. It involves creating multiple activities and linking them together. The main activity displays buttons to launch a second activity, select a contact, and change the background color. Methods are added to each activity to log lifecycle events to the logcat. When changing color or selecting contact, data is passed back to the main activity using startActivityForResult and onActivityResult. This allows the main activity to update the UI based on the result from other activities.
The document discusses the code assistance features of Visual Studio 2015. It provides examples of how the light bulb icon displays potential fixes for syntax errors and missing code. It also shows how refactoring suggestions are provided to optimize code, such as removing unused namespaces or changing a method to directly return a value rather than using a temporary variable. The light bulb icon assists with code completion, error fixing, and refactoring to improve code quality and developer productivity.
The document provides information on how to become a Vaadin expert by attending official Vaadin trainings to learn best practices, application architecture, and new features. It recommends taking the Vaadin certification exam to boost your career and become a Vaadin Certified Developer. Additional steps suggested include developing skills by building Java web applications, reading documentation, and signing up for trainings and certification.
This document provides a tutorial on creating a custom widget in Rational Host Access Transformation Services (HATS). It describes how to create a custom HTML widget that renders an input field and button. The widget is designed to allow adding a button next to an input field to send a mnemonic keyword for a specific purpose, with the button name and keyword configurable via global variables or direct input. The tutorial covers creating the widget Java class, implementing its settings UI and drawHTML() method to generate the HTML output, and provides an example usage transforming an iSeries screen.
ActiveX is a framework for reusable software components that can be composed to provide application functionality. It was introduced by Microsoft in 1996 and is commonly used in Windows applications and allows components to be embedded in web pages. ActiveX controls can create distributed applications over the internet. They can provide more functionality than Java applets but only run on Internet Explorer and Windows. Malware has been spread using ActiveX controls installed from malicious websites.
The document describes creating new method content elements to add to an existing delivery process for a services oriented architecture (SOA) implementation. Specifically, it involves:
1. Creating a new plugin to contain the new elements, including a content package.
2. Creating a new work product called "Service Implementation" and categorizing it.
3. Adding responsibility for the new work product to the existing "Implementer" role.
4. Adding the new work product as an output to the existing "Implement Design Elements" task by creating a contributing task.
The goal is to enhance the existing delivery process with additional elements for SOA implementation while reusing existing elements where possible. The scenario will be
This document discusses code refactoring techniques in Visual Studio 2015, including inline temporary variables and introducing local variables. It provides an example C# class with a method to fetch products above a certain price, and shows how Visual Studio's code refactoring suggestions can optimize the method in multiple steps. These include removing temporary variables, converting the method to an expression-bodied member, and reducing the code to a single line. The document emphasizes that code refactoring requires an understanding of how the changes will affect the code.
Android User Interface: Basic Form WidgetsAhsanul Karim
This document provides a tutorial on creating various user interface elements in Android applications, including buttons, text fields, checkboxes, radio buttons, toggle buttons, rating bars, and auto-complete text views. It includes code examples for adding each element to an app layout and handling user interactions with them.
1. Create a test project for the Android application to be tested and add the Robotium JAR file to the project.
2. Create a test case class and write test methods to test the main functionality of the Android app by accessing its UI elements, entering sample input, clicking buttons, and asserting expected output.
3. Run the test case to launch the app in an emulator, automatically perform the test steps, and verify the test results.
Steps how to create active x using visual studio 2008Yudep Apoi
The document outlines 17 steps to create an ActiveX control in Visual Studio 2008 using C# that can be deployed via a CAB file and initialized from JavaScript. Key steps include:
1. Creating a class library project and interface to expose the control's methods.
2. Marking the control as safe for scripting by implementing the IObjectSafety interface.
3. Creating an MSI installer for the control.
4. Packaging the MSI into a CAB file for web deployment.
5. Testing initialization and methods of the control via a test ASP.NET page and JavaScript.
Visual studio ide componects dot net framworkDipen Parmar
The document describes the main components of the Visual Studio IDE. It discusses the various menus including File, Edit, View, Project, Build, Format, Data, Tools, Window, and Help. It also covers the main windows of the IDE like the Toolbox Window, Solution Explorer, Properties Window, Output Window, Command Window, and Task List Window.
The Coded UI Test Builder can be used to record manual tests and convert them into Coded UI tests. It also allows viewing of an application's control hierarchy and properties. The four buttons in the Coded UI Test Builder are Record, Show recorded steps, Crosshair, and Generate code. The Record button starts, stops, pauses, and resumes recording. Show recorded steps opens a window showing recorded actions. The Crosshair drags over controls to view properties and hierarchy. Generate code converts recorded actions to code.
An application for regression testing of the PVS-Studio and CppCat analyzers.
Implementing the mechanism of regression testing of the static code analyzers PVS-Studio and CppCat.
Ensuring that tests are run on a large number of open-source C/C++ projects.
Ensuring testing of the analyzers’ operation under all the supported Visual Studio versions.
Providing convenient handling of the differences list, quick view feature, apply changes feature, and so on.
The document describes how to use Mulesoft to connect a CSV file to a Salesforce account. It involves using a File connector to monitor an input folder for CSV files. A Salesforce connector is configured with a username, password and security token. A DataMapper transformer maps the CSV file fields to Salesforce object fields. When run, the application will take CSV contact data from the input folder and upload it to the Salesforce account as new contacts.
This document discusses the purpose of universities through a series of reflective activities and discussions. It begins with questioning what universities are for from both an individual and societal perspective. Participants then engage in individual reflection, group discussions to build consensus, and visual art activities to explore different conceptions of the purpose of higher education. Key purposes that emerge include personal growth, citizenship, social justice, knowledge and intellectual growth, character development, creativity, and understanding one's role in the world. The document concludes by reflecting on universities cultivating educated and virtuous individuals but leaves the overarching question of the purpose of higher education open-ended.
This document discusses content negotiation in ASP.NET Web API 2. It explains what content negotiation is, why it is important, and how to implement it in Web API. Content negotiation allows a client to specify the desired response format using request headers like Accept and Content-Type. Web API uses formatters to serialize the response into the requested format. The document provides examples of configuring formatters to support different media types and customize the JSON output. It also describes how the content negotiation pipeline in Web API works to select the appropriate formatter based on the request headers.
First principles of brilliant teachingTansy Jessop
This document summarizes key principles of brilliant teaching from a conference presentation. It discusses 5 principles: 1) knowing your subject matter, 2) selecting and structuring content, 3) connecting to prior student knowledge, 4) using metaphors and examples, and 5) challenging students with high expectations. Specific techniques are described like formative blogging assignments, connecting course content to students' emotions, and adapting teaching methods across disciplines. The presentation also covered theories of teaching, signature pedagogies of different fields, and myths about innate teaching abilities.
Pedagogic implications of wider purpose of HETansy Jessop
This document discusses research informed teaching (RIT) and provides arguments for its importance. It begins with a brief history of universities from medieval times to the present. It then defines RIT and provides examples. Five compelling reasons for RIT are given: 1) it aligns with degree structures, 2) it is challenging, 3) it introduces students to complex problems, 4) it is exciting and student-centered, and 5) it develops critical thinking. Challenges to RIT are also noted. The document argues RIT benefits students in developing independence, sophistication, research skills, and employability.
This document discusses feedback and its importance in student learning. It outlines four common problems with feedback: the mismatch problem, issues related to the National Student Survey, constraints of quality assurance processes, and disconnection of feedback from future work. Potential solutions discussed include focusing on relationships, emotions, mindsets, dialogue over monologue, and developing feedback cycles across modules to better connect feedback to future learning. The talk advocates taking a more relational approach to feedback through conversation, questioning, and addressing emotional and cognitive barriers to help students actively engage with feedback.
It's ok to lecture: from boredom to brillianceTansy Jessop
This document discusses strategies for making lectures more engaging. It notes that while lectures are often criticized as boring, they remain important for conveying large amounts of complex information. The document explores why lectures persist in universities and provides seven strategies for vivifying lectures, such as starting with questions to pique student interest, connecting to prior knowledge, breaking up lectures with varied activities, using multimedia, and having students reflect on what they learned. Overall, it argues that lectures can be improved by making them more interactive, relatable and inspiring for students.
Demystifying Research Informed Teaching: parallel universes?Tansy Jessop
This document discusses research informed teaching (RIT) and debunks common myths about it. It defines different types of RIT, such as research-tutored, research-oriented, and research-based teaching. The document argues that RIT is not limited to research-intensive universities and that research-active lecturers do not necessarily provide better RIT. It also challenges the myth that RIT cannot be done with first-year undergraduate students, noting that exposing students to uncertainty and multiple perspectives can help develop more sophisticated thinking. The document concludes that RIT provides benefits to students such as improved self-confidence, independence, grades, and employability skills.
This document provides an overview of the history and development of the Visual Basic programming language. It discusses how Visual Basic originated from the BASIC language in the 1960s and was later adapted for microcomputers by Bill Gates and Paul Allen in the 1970s. Every version of Basic since has been based on their early work. Visual Basic was then introduced by Microsoft in 1991 and continued to be updated with new features and capabilities in subsequent versions like Visual Basic 3.0, 4.0, 5.0 and 6.0. The document also defines some key Visual Basic concepts and terms.
The document provides instructions for building an Android app that makes an API call to GitHub to retrieve a list of Java developers in Nairobi. It retrieves the data using Volley, parses the JSON response, and displays the developer names, images, and URLs in a RecyclerView with CardViews. It also describes how to set up an adapter to connect the data to the RecyclerView items, create a model class to store the developer data, and add a click handler to launch a profile activity with more details when an item is tapped.
Repository Pattern in MVC3 Application with Entity FrameworkAkhil Mittal
The document discusses implementing a repository pattern in an MVC application using Entity Framework. It begins with an introduction and roadmap of previous articles. It then discusses the benefits of a repository pattern in abstracting the data access layer from business logic. Steps are provided to create a sample repository interface and class to implement basic CRUD operations on a User entity, abstracting the data access code from the controller. The repository class uses the Entity Framework context to perform operations while resolving tight coupling issues between layers. It concludes that while this implementation works for a single entity, a generic repository will be needed to cleanly support multiple entities without duplication.
This document describes how to rapidly develop a web application using ASP.NET MVC 3 in Microsoft Visual Studio 2010. It outlines how to create a new project, add models, contexts, controllers with CRUD functionality, and use HTML helpers and dynamic templates to simplify development. MVC 3 enables full control over HTML while separating concerns, and allows both basic and complex applications to be built quickly through its RAD elements integrated into Visual Studio.
This document provides instructions for reformatting a document delivered in 8.5x11 US letter format to print on A4 paper. It outlines four simple steps: 1) Open the document in Word and select A4 paper size, 2) Update the second page, 3) Reindex the last page, and 4) Save under a new name for convenience. The document also introduces automated testing and the TestComplete tool for creating tests.
This paper’s aim is to point out the RAD ( Rapid application development) elements present in the Microsoft’s MVC 3 and WCF 4.0 using Microsoft Visual Studio 2010. It will describe why creating a new web application using MVC 3 and WCF 4.0 is a easy and fast and also present simple ways to develop such applications.
The document discusses refactoring tips provided by Martin Fowler. It defines refactoring as improving the internal structure of software without changing its external behavior. It provides examples of common refactoring techniques like extract method, inline method, move method, and consolidate conditional expressions. The goal of refactoring is to improve code quality by making software easier to understand and modify over time.
This tutorial provides an overview of creating a sample Django application that demonstrates basic components including models, views, templates, URLs, forms, and the admin site. Key steps covered include:
- Setting up a Django project in Eclipse with Python, Django, SQLite
- Creating models, views, URLs, and templates
- Using the Django admin site to populate the database
- Displaying model data in templates
- Creating and processing a basic form
Generic Repository Pattern in MVC3 Application with Entity FrameworkAkhil Mittal
This document discusses implementing a generic repository pattern and unit of work pattern in an MVC application using Entity Framework. It begins by introducing the concepts of a generic repository and unit of work. It then shows how to create a generic repository class that can be used for any entity. A unit of work class is created to manage transactions and repositories. Properties on the unit of work class provide access to repositories without having to create separate classes. CRUD operations on entities are demonstrated using the generic repository through the unit of work. This completes the tutorial on implementing these patterns to reduce redundant code and complexity in an MVC application.
This document provides an overview of setting up Oracle General Ledger. It discusses defining ledger sets which includes creating a chart of accounts, calendar, currency, accounting setups and ledger sets. It also covers opening periods, journal entries, budgeting, reporting currencies, consolidations and generating standard reports. Specifically, it outlines the steps to create a chart of accounts including defining key flexfield segments, segments, value sets and qualifiers. It also describes defining period types and creating a new calendar.
This document discusses creating an MVC application from scratch using LINQ to SQL to perform CRUD operations on a database. It covers:
1. Creating an empty MVC project and adding controllers, views and models
2. Creating a sample database and using LINQ to SQL for communication between the MVC app and database
3. Performing CRUD operations in the MVC app by querying the database and passing data between controllers and views
Object Oriented Analysis and Design with UML2 part2Haitham Raik
The document discusses object-oriented analysis and design principles. It covers object-oriented analysis, which involves identifying core concepts or domain classes from requirements. It then discusses object-oriented design principles like SOLID - single responsibility principle, open/closed principle, Liskov substitution principle, interface segregation principle, and dependency inversion principle. Design patterns are also mentioned.
This document provides an overview of Visual Basic 6.0 and how to create a basic application. It outlines the objectives of learning Visual Basic and describes key concepts like the event-driven nature of VB applications. The document explains the structure of a VB project, including forms, controls, properties, methods and events. It also demonstrates how to set control properties, write code, declare variables, and use common functions and operators. Finally, it provides examples for creating a stopwatch timer application and a basic text editor application in VB.
Visual Basic is an event-driven programming language developed by Microsoft. It was introduced in 1991 and helped popularize graphical user interface (GUI) programming. Some key points:
- The original BASIC language was developed in the 1960s and was simpler than other languages at the time like FORTRAN.
- Bill Gates and Paul Allen wrote the first BASIC for microcomputers in the 1970s, which became the foundation for later versions like GW-BASIC and QBASIC.
- Visual Basic 6.0 introduced improvements like a faster compiler and support for database integration and internet capabilities.
- It uses an integrated development environment (IDE) and is based on creating and linking together objects to build Windows applications and
Unveiled at WWDC 2015, Swift 2.0 is an enhanced update with integrated functionalities of its previous version Swift 1.2, thereby providing broader platform for programmers for generating the code. The upgraded version of programming language has been designed more powerful and interfacing for the users.
The document discusses tools and techniques for making Java development more enjoyable. It recommends using libraries like Mockito, Guice and Guava to simplify testing and dependency injection. It also suggests using builder patterns, writing concise yet descriptive unit tests, and avoiding string-typing in favor of object-oriented types.
The document describes creating an ASP.NET Web API project to perform CRUD operations on products. It includes creating a Product model and ProductManager class to manage products. A ProductController is added to handle GET, POST, PUT, and DELETE requests for products by calling methods on the ProductManager. The Web API project is configured to use routing and the default ValuesController is removed. This establishes the backend API portion, with the next part covering consuming the API through a client.
This document discusses software design principles and practices to avoid bad design that results in software that is rigid, fragile, and difficult to change. It recommends applying principles like the single responsibility principle and dependency inversion principle. It also recommends using software metrics and tools like Visual Studio to help evaluate designs and refactor as needed. Refactoring is important to apply these principles and keep software flexible over time as needs change.
The document describes the features and interface of the Programming Without Coding Technology (PWCT) environment. The PWCT environment allows visual programming through a graphical interface and contains various windows and tools for visual programming, including a server units window to manage server code, a goal designer to create goals to override code, and designers for interactions and transporters. It provides features like visual programming languages, framework extensions, and supports multiple operating systems.
Release planning is a challenging but important part of the agile development process. There are two main approaches to release planning: fixed timeline and fixed scope of work. With a fixed timeline, the deadline cannot be extended and functionality may need to be cut, while a fixed scope defines what must be included regardless of timeline. The objective of release planning is to baseline the product roadmap and team commitments, while allowing flexibility based on which approach is chosen.
This document discusses extending OData support in ASP.NET Web APIs. It provides an introduction to OData and the roadmap for a RESTful Web API series. It describes setting up a solution to add OData support and modifying existing API endpoints to be OData enabled. This allows queries to support options like $top, $filter, $orderby and more to filter, sort, page and select data from the server.
The document describes setting up unit testing for a Web API project using NUnit and Moq frameworks. It includes:
1. Adding a test project and installing necessary packages like NUnit, Moq, EntityFramework, and Newtonsoft.Json.
2. Defining variables and setting up mocks for the repositories, services, and UnitOfWork classes needed for the tests.
3. Writing tests for the ProductController including getting all products, getting a product by ID, and testing exceptions.
4. Explaining how to mock the repositories to simulate database operations during the tests.
So in summary, it covers the steps to set up a Web API project for unit testing and then provides examples
This document discusses unit testing Web APIs using the NUnit and Moq frameworks. It provides an overview of unit testing and the NUnit and Moq frameworks. It then details setting up a test project and installing necessary packages. The document focuses on writing unit tests for the business logic layer and controllers, demonstrating how to test a ProductService class by mocking dependencies, writing test methods, and more.
The document discusses implementing request and exception logging in ASP.NET Web APIs using NLog, Action Filters, and Exception Filters. It describes setting up NLog configuration, creating an NLogger class to handle logging, and adding an Action Filter (LoggingFilterAttribute) to log requests. It also covers adding an Exception Filter (GlobalExceptionAttribute) to log exceptions, modifying classes to support exception logging, and throwing an exception to test the exception logging.
MVC Application using EntityFramework Code-First approach Part4Akhil Mittal
This document discusses connecting an MVC application to a database using Entity Framework's Code First approach. It explains that with Code First, domain models are designed first before the database is automatically generated. The steps shown create a DbContext class that inherits from DbContext and defines a DbSet for the User model. A connection string is added and the DbContext is used instead of the prior Entity Data Model classes. When run, the database is dynamically generated based on the model, allowing CRUD operations on the User table through the application and Entity Framework.
Learning MVC Part 3 Creating MVC Application with EntityFrameworkAkhil Mittal
This document discusses connecting an existing MVC application to a database using Entity Framework instead of LINQ to SQL. It provides steps to generate an Entity Data Model from an existing database, generate strongly typed entity classes, and modify the application's controllers to use the Entity Framework context instead of the LINQ to SQL context. The key steps are: 1) Adding an Entity Data Model file and generating entity classes; 2) Modifying controllers to use the Entity Framework context instead of LINQ to SQL; 3) Binding views to the generated entity classes. The document emphasizes that Entity Framework automates CRUD operations and allows focusing on business logic rather than data access code.
This document introduces the MVC architecture and separation of concerns. It outlines a 6 part roadmap to cover MVC fundamentals and implementing it with Entity Framework. Part 1 introduces MVC, defining the roles of models, views, and controllers. It explains how MVC separates the application into independent and reusable components for the model, views for presentation, and controllers for handling requests. This separation aims to improve maintainability and extensibility of applications.
This document discusses implementing security in a Web API using basic authentication and token-based authorization. It introduces basic authentication as a means of validating a user's credentials through a username and password sent in the request header. Token-based authorization is described as sending a token to authenticated users that allows them to access other resources. The document then outlines steps to create a user service, implement basic authentication using an authentication filter, and implement token-based authorization by setting up databases, services, and controllers and marking them with an authorization filter. Maintaining sessions with tokens is also briefly mentioned.
C sharp and asp.net interview questionsAkhil Mittal
The document provides summaries of common questions and answers related to ASP.NET, C#, and the .NET framework. It defines view state as storing the current property settings of an ASP.NET page and controls to detect form submissions. It explains that user controls allow reusing ASP.NET pages as controls, and validation controls perform input checking on server controls. The document also distinguishes between Response.Write and Response.Output.Write, and lists page life cycle methods like Init, Load, and Unload.
This document provides answers to common ASP.NET interview questions. It begins with questions about the differences between custom controls and user controls, ASP session state and ASP.NET session state, and datasets versus recordsets in ADO.NET. Subsequent questions cover topics like view state, authentication, caching, validation controls, and working with data controls.
Diving in OOP (Day 1) : Polymorphism and Inheritance (Early Binding/Compile T...Akhil Mittal
I have been writing a lot about advanced topics like MVC, Entity Framework, Repository Patterns etc., my priority always remains to cover the topic as a whole, so that a reader do not have to search for missing links anywhere else. My this article will cover almost every OOPS concept that a novice/beginner developer hunt for, and not only beginners, the article’s purpose is to be helpful to experience professionals also who need to sometimes brush-up their concepts or who prepare for interviews .
Custom URL Re-Writing/Routing using Attribute Routes in MVC 4 Web APIsAkhil Mittal
We have already learnt a lot on WebAPI. I have already explained how to create WebAPI, connect it with database using Entity Framework, resolving dependencies using Unity Container as well as using MEF. In all our sample applications we were using default route that MVC provides us for CRUD operations. In this article I’ll explain how to write your own custom routes using Attribute Routing. We’ll deal with Action level routing as well as Controller level routing. I’ll explain this in detail with the help of a sample application. My new readers can use any Web API sample they have, else you can also use the sample applications we developed in my previous articles.
Resolve dependency of dependencies using Inversion of Control and dependency ...Akhil Mittal
In my last two articles I explained how to create a RESTful service using ASP.NET Web API working with Entity Framework and resolving dependencies using Unity Container. In this article I’ll explain how to create a loosely coupled system with Unity Container and MEF(Managed Extensibility Framework) using Inversion of Control. I’ll not be explaining much theory but rather focus more on practical implementations. For the readers who are following this series, they can use their existing solution that they have created till time. For my new readers of this article, I have provided the download link for the previous source code and current source code as well.
For theory and understanding of DI and IOC you can follow the following links: Unity and Inversion of Control(IOC).
Inversion of control using dependency injection in Web APIs using Unity Conta...Akhil Mittal
My article will explain how we can make our Web API service architecture loosely coupled and more flexible. We already learnt that how we can create a RESTful service using Asp.net Web API and Entity framework in my last article. If you remember we ended up in a solution with a design flaw, we’ll try to overcome that flaw by resolving the dependencies of dependent components. For those who have not followed my previous article, they can learn by having the sample project attached as a test application from my first article.
Diving in OOP (Day 6): Understanding Enums in C# (A Practical Approach)Akhil Mittal
My article of the series “Diving in OOP” will explain enum datatype in C#. We’ll learn by doing hands on lab and not only by theory. We’ll explore the power of enum and will cover almost every scenario in which we can use enum. We’ll follow a practical approach of learning to understand this concept. We may come across complex examples to understand the concept more deeply.
Diving into OOP (Day 5): All About C# Access Modifiers (Public/Private/Protec...Akhil Mittal
Access modifiers (or access specifiers) are keywords in object-oriented languages that set the accessibility of classes, methods, and other members. Access modifiers are a specific part of programming language syntax used to facilitate the encapsulation of components.
Diving in OOP (Day 3): Polymorphism and Inheritance (Dynamic Binding/Run Time...Akhil Mittal
The document discusses runtime polymorphism in C# using method overriding. It shows how to override methods in a derived class by marking the base class methods as virtual and using the override keyword in the derived class. An experiment is conducted where calling a method on an object initialized as the base class but actually referring to a derived class instance results in the overridden method from the derived class being called due to runtime binding.
Diving in OOP (Day 4): Polymorphism and Inheritance (All About Abstract Class...Akhil Mittal
This document provides an overview of abstract classes in C# object-oriented programming. It defines abstract classes as classes that cannot be instantiated and must be implemented in derived classes. The document demonstrates several key features of abstract classes through code examples, including: defining abstract and non-abstract methods in abstract classes; inheriting from abstract classes to instantiate derived classes; and requiring derived classes to implement abstract methods from the base abstract class.
Diving in OOP (Day 4): Polymorphism and Inheritance (All About Abstract Class...
Diving into VS 2015 Day3
1. Diving into Visual Studio 2015 (Day #3): Renaming
Assistance
Introduction
In this part of the article series on learning Visual Studio 2015 we’ll cover topic named renaming in Visual Studio 2015.
Yes Visual Studio 2015 provides a great capability of refactoring/renaming the code. It helps developer to optimize and
refactor the code as per the development or best practices need. This feature enables developer to follow best practices
by giving refactoring suggestions as well as helping in fixing and optimizing the code. Renaming the variables, methods,
properties, classes or even projects has always been a challenge to a developer when working on large code base.
Another challenge that most of the developers face is w.r.t. code comments and writing an optimized method. Visual
Studio 2015 helps in code refactoring and renaming as well in a very easy and friendly way.
Code Renaming
There are a lot of features that this capability of renaming covers in visual Studio 2015.Change preview,inline and
modeless rename windows, renaming on the fly, detecting and resolving conflicts, renaming code comments are few of
them. Let us discuss each one in detail via practical examples. I am using Visual Studio 2015 Enterprise edition and have
created a console application named VS2015ConsoleApplication having an interface named IProducts and a class named
MyProducts that implements the interface.IProducts contains two methods, one to return product based on product
code and another to return complete list of products. Product.cs is another class containing Product entity. This class
acts as a transfer object or entity. We’ll use Main method of Program.cs class to invoke methods of MyProducts class.
IProducts
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace VS2015ConsoleApplication
8: {
9: interface IProducts
3. 23: {
24: return _productList.Find(p => p.ProductCode == productCode);
25: }
26:
27: public List<Product> GetProductList()
28: {
29: return _productList;
30: }
31: }
32: }
Program.cs
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace VS2015ConsoleApplication
8: {
9: class Program
10: {
11: static void Main()
12: {
13: var myProducts = new MyProducts();
14: Console.WriteLine( String.Format("Product with code 0002 is : {0}",
myProducts.GetProduct("0002").ProductName));
15: Console.WriteLine(Environment.NewLine);
16: var productList = myProducts.GetProductList();
17: Console.WriteLine("Following are all the products");
18:
19: foreach (var product in productList)
20: {
21: Console.WriteLine(product.ProductName);
22: }
23: Console.ReadLine();
24: }
25: }
26: }
Our code is ready. Program file’s main method calls both the interface methods from MyProducts class to test the
functionality.
4. We’ll use this code base to learn code renaming features.The renaming experience may vary w.r.t. what actual
operation is being performed. For example in MyProducts class we are using _productList as a variable containing list of
all products, and this variable is widely used throughout the class.
Let us try to rename this variable to a new name called _allProducts.
5. Notice that as soon as _productsList is changed to _allProduct, a dotted box is shown around the changed variable name
and a light bulb icon appears at the left. One can see one more change, that all the instances where _productList was
used has a red line below them. This means that all the instances should be changed accordingly. You can see here the
power of Visual Studio. Visual studio is smart enough to understand and communicate that the change that a developer
is making has to be reflected to other places too. Let us see what Light bulb icon says. Let us click on light bulb icon
appeared at the left margin.
The light bulb icon shows some suggestions that we learnt in Day #1 and Day #2 of this article series. There is one new
suggestion that Light bulb icon is showing now and that is regarding “Rename”. In the suggestion window Light bulb icon
shows all the _productList instances highlighted and says to rename all the instances to new name i.e _allProducts.
When you preview the changes by clicking “Preview Changes ” link shown at the bottom of suggestion window, it shows
the resultant changes that you’ll get once variable is renamed.
6. In preview you can clearly see the changes that will take place once the variable is renamed. Let us click on apply
changes, and you’ll see the method has a new changed variable now at all the instances.
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace VS2015ConsoleApplication
8: {
9: public class MyProducts :IProducts
10: {
11: List<Product> _allProduct = new List<Product>();
12: public MyProducts()
13: {
14: _allProduct.Add(new Product
{ProductCode="0001",ProductName="IPhone",ProductPrice="60000",ProductType="Phone",ProductDescription="Apple
IPhone" } );
15: _allProduct.Add(new Product { ProductCode = "0002", ProductName = "Canvas", ProductPrice =
"20000", ProductType = "Phone", ProductDescription = "Micromax phone" });
7. 16: _allProduct.Add(new Product { ProductCode = "0003", ProductName = "IPad", ProductPrice =
"30000", ProductType = "Tab", ProductDescription = "Apple IPad" });
17: _allProduct.Add(new Product { ProductCode = "0004", ProductName = "Nexus", ProductPrice =
"30000", ProductType = "Phone", ProductDescription = "Google Phone" });
18: _allProduct.Add(new Product { ProductCode = "0005", ProductName = "S6", ProductPrice =
"40000", ProductType = "Phone", ProductDescription = "Samsung phone" });
19:
20: }
21:
22: public Product GetProduct(string productCode)
23: {
24: return _allProduct.Find(p => p.ProductCode == productCode);
25: }
26:
27: public List<Product> GetProductList()
28: {
29: return _allProduct;
30: }
31: }
32: }
Now let’s run the application to check if the changes had an impact on the functionality of the application.Press F5.
It is clearly seen that application has no build error and produces the same result as earlier. There is one thing that a
developer needs to take care of, sometimes renaming may be risky and tricky in large code base, so while renaming it is
suggested to have a glance over preview i.e. given by suggestion window.
Let us take another scenario.Open the Program.cs file and perform rename on myProducts object.
8. This time we’ll do renaming through context menu. Right click on myProducts object name and you’ll see the context
menu open. There is an option of rename on the opened context menu.
In front of Rename option, there is a shortcut available too Ctrl+R, Ctrl+R. When you select Rename, you’ll notice that
the renaming experience here is different , all the instances of the renaming gets highlighted.There is a new window that
appears at the right corner of code window having few other options. Now if you rename the object name, the other
highlighted variables get renamed on the fly while typing. To close the Rename window you can click cross button on
that window. Notice that this option of renaming through context menu is much faster that the earlier one, and enables
you to rename on the fly in a single step with live preview while typing. Once the variable is renamed and you close the
window, all the highlighting will be gone and you get a clean renamed variable at all the occurrences.
9. I changed the object name from myProducts to products.
1: using System;
2: using System.Collections.Generic;
3: using System.Linq;
4: using System.Text;
5: using System.Threading.Tasks;
6:
7: namespace VS2015ConsoleApplication
8: {
9: class Program
10: {
11: static void Main()
12: {
13: var myProducts = new MyProducts();
14: Console.WriteLine( String.Format("Product with code 0002 is : {0}",
myProducts.GetProduct("0002").ProductName));
15: Console.WriteLine(Environment.NewLine);
16: var productList = myProducts.GetProductList();
17: Console.WriteLine("Following are all the products");
18:
19: foreach (var product in productList)
20: {
21: Console.WriteLine(product.ProductName);
22: }
23: Console.ReadLine();
24: }
25: }
26: }
Rename Conflicts
Let us take another scenario where we try to rename a variable to another name that is already assigned to any other
variable in the same method or try to rename a property of a class having another property having same name as of new
name. Let us open Product class for example. Product class contains the Product properties, let us try to rename
ProductName property. Right click on ProductName property and open Rename window by clicking Rename from
context menu.
10. We’ll change the name of ProductName property to ProductCode.We already have ProductCode property available in
this class. Let us see what happens.Notice that when you start typing the new name of ProductName property to
ProductCode, the rename window shows error with Red color, and the already exiting ProductCode propert also shows a
red box around it.
Here Visual Studio 2015 smartly tells that the new property name already exists in the class and this change may result
in having conflicts. Now you know that this change may cause your application to break, so just press escape and the
rename window will be gone with your new name reverted to old one.
11. Therefore Visual Studio helps to detect any renaming conflicts and suggest to resolve them.
Rename Overloads, Strings, Code Comments
Let us take one more scenario. Add an overload method named GetProduct to IProduct interface and implement that
menthod in MyProducts class.
1: interface IProducts
2: {
3: Product GetProduct(string productCode);
4: Product GetProduct(string productCode,string productName);
5: List<Product> GetProductList();
6: }
1: /// <summary>
2: /// GetProduct
3: /// </summary>
4: /// <param name="productCode"></param>
5: /// <returns></returns>
6: public Product GetProduct(string productCode)
7: {
8: return _allProduct.Find(p => p.ProductCode == productCode);
9: }
10:
11: /// <summary>
12: /// GetProduct with productCode and productName
13: /// </summary>
14: /// <param name="productCode"></param>
15: /// <param name="productName"></param>
16: /// <returns></returns>
12. 17: public Product GetProduct(string productCode, string productName)
18: {
19: return _allProduct.Find(p => p.ProductCode == productCode && p.ProductName==productName);
20: }
21:
Now try to rename the GetProduct method in MyProducts class. Put the cursor in between the GetProduct method
name and press Ctrl+R, Ctrl+R.The rename window will be opened as shown below.
You see here the Rename window opens having few more options as shown below.
If you select the checkbox to include overloads, the overloads of that method which we are renaming also gets renamed,
in this case if we choos thos option the overloaded method of GetProduct() also gets renamed.
13. If we also choose the second option then the code comments also get renamed when we rename the method to new
name. The name if exists in code comments also gets renamed to new name.
The renaming option also allows to rename related strings for that name, i.e. the third option. You can also preview the
changes before renaming. preview changes window shows you all the occurences that will remain, and provides you an
option again to review and select un-select the change you want to take place at particular instance.Here I am trying to
change GetProduct name to FetchProduct . Let us check Preview changes check box and press Apply button.
14. A preview window will get opened. Notice that not only for particular file but this window accumulates all the possible
areas where this change may take place and affect code like in MyProduct.cs file, IProducts.cs interface and program.cs
file. it says that when method name is changed, it will reflect in these files as well. Now it is the choice of a developer,
whether to let that change happen or not. So preview window gives an option to developer to check or un-check the
checkbox for corresponding affected file for that change to take place or not. The code suggestion and code assistance
mechanism of Visual Studio is so string that it takes care of all these modifications and automations very smartly.
In this case I didn’t un-select any of the file and let that change happen. it automatically renamed GetProduct to Fetch
Product to all the areas shown including Comments, Interface and Program file as well.
In a similar way you can also rename the parameters passed in a method, this will also include all the possible renaming
options like rename in comments and methods.Like shown in the following image, if I try to rename the parameter of
FetchProduct method, it highlights all the possible renaming changes.
Put the cursor between productCode and press Ctrl+R, Ctrl+R, the rename window will appear and all instances of
parameter gets highlighted, even the comment too.Change the name to pCode and click on apply.
15. We see the parameter name is changed along with the name in comment too.
Conclusion
In this article we covered Renaming assistance provided by Visual Studio 2015. We learnt about the renaming
experience in various ways that includes following bullet points.
Renaming assistance through light bulb actions
Change preview with smart suggestions.
Rename window and its renaming options.
On the fly , live renaming experience. Rename as you type.
Conflict detection and resolution while renaming.
Renaming code comments.
In the next section of this series, I’ll cover code refactoring in Visual Studio 2015.
For more technical articles you can reach out to my personal blog, CodeTeddy.
Read More
Diving into Visual Studio 2015 (Day #1) : Code Assistance
Diving into Visual Studio 2015 (Day #2): Code Analyzers