Róbert Kanász - blog venujúci sa programovaniu na platforme .NET

MCTS Web Applications .NET 4 – 70-515 – Objectives List Part 6

kanasz.robert — Sun, 13 Nov 2011 14:32:17 GMT

Create custom routes

Create controllers and actions.

Visual Studio support for right-click context menus
Action filters (including Authorize, AcceptVerbs, and custom) and model binders
ActionResult sub-classes

Structure an ASP.NET MVC application.

single project areas (for example, route registration, Visual Studio tooling, and inter-area links)
Organizing controllers into areas
Shared views
Content files and folders

Create and customize views.

built-in and custom HTML helpers (for example, HTML.RenderAction and HTML.RenderPartial)
- RenderAction
  - Rendering a Form in ASP.NET MVC Using HTML Helpers
Strongly typed views
Static page checking
Templated input helpers
ViewMasterPage
ViewUserControl

MCTS Web Applications .NET 4 – 70-515 – Objectives List Part 5

kanasz.robert — Sun, 13 Nov 2011 14:31:00 GMT

Implement data-bound controls

Implement DataSource controls

Query and manipulate data by using LINQ

Create and consume a data service.

Create and configure a Dynamic Data project

MCTS Web Applications .NET 4 – 70-515 – Objectives List Part 4

kanasz.robert — Sun, 13 Nov 2011 14:29:54 GMT

Configure authentication and authorization

Configure providers

Create and configure HttpHandlers and HttpModules

Generic handlers
- IHttpHandler
- IHttpModule
Asynchronous handlers
Setting MIME types and other content headers
- Response.AddHeader
- Response.ContentType
Wiring modules to application events

Configure initialization and error handling
This objective may include but is not limited to:

Reference and configure ASMX and WCF services

Configure projects and solutions, and reference assemblies

Local assemblies
Shared assemblies (global assembly cache)
Web application projects
Settings file
Configuring a Web application by using web.config or multiple .config files
AssemblyInfo
- How To: Create Versioned Assemblies for Precompiled Web Sites

Debug a Web application

Deploy a Web application

MCTS Web Applications .NET 4 – 70-515 – Objectives List Part 3

kanasz.robert — Sun, 13 Nov 2011 14:28:01 GMT

Add dynamic features to a page by using JavaScript

Alter a page dynamically by manipulating the DOM

Handle JavaScript events

Implement ASP.NET AJAX

Implement AJAX by using jQuery.

MCTS Web Applications .NET 4 – 70-515 – Objectives List Part 2

kanasz.robert — Sun, 13 Nov 2011 14:26:27 GMT

Validate user input.

Create page layout.

Implement user controls.

Implement server controls

Manipulate user interface controls from code-behind.

MCTS Web Applications .NET 4 – 70-515 – Objectives List Part 1

kanasz.robert — Sun, 13 Nov 2011 14:25:10 GMT

Configure Web Forms pages.

Implement master pages and themes.

Implement globalization

Handle page life cycle events

IsPostback
- How to: Determine How ASP.NET Web Pages Were Invoked
IsValid
- How to: Disable Validation for ASP.NET Server Controls
- How to: Display Server Side Custom Validation Messages for ASP.NET Server Controls
dynamically creating controls
- PlaceHolder
- Dynamic Web Server Controls and View State
control availability within the page life cycle
accessing control values on postback
overriding page events
- PreInit
- Init
- InitComplete
- PreLoad
- Load
- LoadComplete
- PreRender
- PreRenderComplete
- SaveStateComplete
- Render
- Unload

Implement caching.

Manage state.

Jednoduchý performance test v C# pomocou System.Diagnostics.Stopwach

kanasz.robert — Tue, 08 Nov 2011 17:44:37 GMT

Každý vývojár, ktorý sa zaoberá optimalizáciou výkonu, skôr alebo neskôr natrafí na na triedu StopWatch nachádzajúcej sa v mennom priestore System.Diagnostics. V prípade, ak ste už niekedy robili testy výkonu, určite ste si už stihli všimnúť že výsledky sa môžu líšiť až o 25%-30%. V tomto článku vám ukážem, ako optimálne navrhovať jednovláknové testovacie programy tak, aby rozdiel vo výsledkoch bol v rozmedzí 0.1%-0.2%.

V dnešnej dobe majú moderné počítače procesory s viacerými jadrami, veľkou cache atď. a inými vecami, ktoré môžu výrazne ovplyvniť čas vykonávania algoritmu. Tzv. White Box techniky s attachnutym debuggerom výrazne skresľujú výsledky testov a spomaľujú vykonávanie algoritmu, pretože CPU je zaťažované väčším množstvom inštrukcií. Na druhej strane Black Box techniky s neattachnutým debuggerom nám poskytujú ďaleko viac relevantných informácií.

Jedna z najdôležitejších vecí je zabezpečiť, aby sa funkcia vykonávala práve na jednom jadre procesora. To môžeme docieliť nastavením vlastnosti ProcessorAffinity nášho procesu:

Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(2);

V ďalšom kroku musíme zabezpečiť, aby ostatné vlákna nevyužívali naše jadro/procesor. Toho docielime tak, že nastavíme nášmu vláknu najvyššiu prioritu a ostaným nižšiu:

Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
Thread.CurrentThread.Priority = ThreadPriority.Highest;

Ešte pred začatím samotného testovania, je nutné spraviť tzv. zahrievacie kolo (Warmup), po ktorom by mali byť výsledky už viac menej stabilné. V nasledujúcom príklade som zvolil dĺžku Warmup fázy 1200 ms (dĺžka warmupu sa môže na rôznych počítačoch meniť).

stopwatch.Start();
while (stopwatch.ElapsedMilliseconds < 1200)
{
    result = TestFunction(seed, count); 
}
stopwatch.Stop();

Kompletný príklad:

using System;
using System.Diagnostics;
using System.Threading;

namespace PreciseMeasure
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch stopwatch = new Stopwatch();

long seed = Environment.TickCount; long result = 0;
int count = 100000000;

            Console.WriteLine("20 testov bez korektnej prípravy");
            Console.WriteLine("Warmup");
            for (int repeat = 0; repeat < 20; ++repeat)
            {
                stopwatch.Reset();
                stopwatch.Start();
                result ^= TestFunction(seed, count);
                stopwatch.Stop();
                Console.WriteLine("Ticks: " + stopwatch.ElapsedTicks +" mS: " + stopwatch.ElapsedMilliseconds);
            }

Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(2);
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High; Thread.CurrentThread.Priority = ThreadPriority.Highest;

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("20 testov s korektnou pripravou");
            Console.WriteLine("Warmup");
            stopwatch.Reset();
            stopwatch.Start();
            while (stopwatch.ElapsedMilliseconds < 1200)
            {
                result = TestFunction(seed, count); // Warmup
            }
            stopwatch.Stop();

            for (int repeat = 0; repeat < 20; ++repeat)
            {
                stopwatch.Reset();
                stopwatch.Start();
                result ^= TestFunction(seed, count);
                stopwatch.Stop();
                Console.WriteLine("Ticks: " + stopwatch.ElapsedTicks +
                " mS: " + stopwatch.ElapsedMilliseconds);
            }
            Console.WriteLine(result);
        }

        public static long TestFunction(long seed, int count)
        {
            long result = seed;
            for (int i = 0; i < count; ++i)
            {
                result ^= i ^ seed;
            }
            return result;
        }
    }
}

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 7 (Gathering Performance Information)

kanasz.robert — Wed, 02 Nov 2011 12:46:00 GMT

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 5 (Working with Additional SQL Server Components)

kanasz.robert — Wed, 02 Nov 2011 12:45:00 GMT

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 6 (Working with XML Data)

kanasz.robert — Wed, 02 Nov 2011 12:45:00 GMT

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 4 (Applying Additional Query Techniques)

kanasz.robert — Wed, 02 Nov 2011 12:42:00 GMT

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 3 (Working with Query Fundamentals)

kanasz.robert — Wed, 02 Nov 2011 12:41:00 GMT

Query data by using SELECT statements
Modify data by using INSERT, UPDATE, and DELETE statements
Return data by using the OUTPUT clause
Modify data by using MERGE statements
Implement aggregate queries
Combine datasets
Apply built-in scalar functions

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 2 (Implementing Programming Objects)

kanasz.robert — Wed, 02 Nov 2011 12:40:00 GMT

Create and alter stored procedures
- Understanding Stored Procedures
  - Stored Procedure Basics
  - Types of Stored Procedures
- Designing Stored Procedures (Database Engine)
- Implementing Stored Procedures
- CREATE PROCEDURE (Transact-SQL)
Table-Valued Parameters(TVPs)
- Table-Valued Parameters (Database Engine)
EXECUTE AS
- EXECUTE AS (Transact-SQL)
- EXECUTE AS Clause (Transact-SQL)
- Understanding Context Switching
- Understanding Execution Context
- Understanding Impersonation
- Tutorial: Ownership Chains and Context Switching
RECOMPILE
- Recompiling Stored Procedures
- Query Hints (Transact-SQL)
- Optimizing Queries in Deployed Applications by Using Plan Guides
Parameter direction (output)
- Specifying Parameters
WITH ENCRYPTION
- Look at CREATE PROCEDURE (Transact-SQL)
Manage permissions (GRANT, DENY, REVOKE)
- Permissions (Database Engine)
- GRANT Object Permissions (Transact-SQL)
- DENY Object Permissions (Transact-SQL)
- REVOKE Object Permissions (Transact-SQL)
Create and alter user-defined functions (UDFs)
- Understanding User-defined Functions
- User-Defined Function Basics
- Types of Functions
- Designing User-Defined Functions
- User-Defined Function Design Guidelines
- Table-Valued User-Defined Functions
- Inline User-Defined Functions
- Deterministic and Nondeterministic Functions
- Rewriting Stored Procedures as Functions
- Implementing User-defined Functions
- Creating User-Defined Functions (Database Engine)
- Creating User-Defined Aggregates
- Creating CLR Functions
Create and alter DML triggers
- Understanding DML Triggers
- Types of DML Triggers
- Triggers Compared to Constraints
- Designing DML Triggers
- Implementing DML Triggers
INSERT
- CREATE TRIGGER (Transact-SQL)
DELETE
- CREATE TRIGGER (Transact-SQL)
INSTEAD OF
- Designing INSTEAD OF Triggers
- CREATE TRIGGER (Transact-SQL)
- INSTEAD OF INSERT Triggers
- INSTEAD OF UPDATE Triggers
- INSTEAD OF DELETE Triggers
- Expressions and Computed Columns in INSTEAD OF Triggers
- Using text, ntext, and image Data in INSTEAD OF Triggers
Create and alter DDL triggers
- Understanding DDL Triggers
- Designing DDL Triggers
- Implementing DDL Triggers
- Getting Information About DDL Triggers
- Understanding DDL Triggers vs... DML Triggers
- CREATE TRIGGER (Transact-SQL)
- DROP TRIGGER (Transact-SQL)
- ALTER TRIGGER (Transact-SQL)
- sys.sql_expression_dependencies (Transact-SQL)
- sys.dm_sql_referenced_entities (Transact-SQL)
- sys.dm_sql_referencing_entities (Transact-SQL)
Enabling/disabling
- DISABLE TRIGGER (Transact-SQL)
- ENABLE TRIGGER (Transact-SQL)
Return event data
- EVENTDATA (Transact-SQL)
- Using the EVENTDATA Function
Create and deploy CLR-based objects
- Assemblies
- Creating CLR Functions
- Creating CLR Stored Procedures
- Programming CLR Triggers
- Creating User-Defined Aggregates
- Working with CLR User-defined Type
Permission sets (SAFE, UNSAFE, EXTERNAL_ACCESS)
- CREATE ASSEMBLY (Transact-SQL)
- Designing Assemblies
- Host Protection Attributes and CLR Integration Programming
- CLR Integration Code Access Security
SET TRUSTWORTHY
- TRUSTWORTHY Database property
Implement error handling
- Understanding Database Engine Errors
- Database Engine Error Severities
TRY/CATCH
- TRY...CATCH (Transact-SQL)
- Using TRY...CATCH in Transact-SQL
RAISERROR
- Using RAISERROR
- RAISERROR (Transact-SQL)
Retrieving error information
- Retrieving Error Information in Transact-SQL
Custom Error Messages
- Using PRINT
- PRINT (Transact-SQL)
@@ERROR
- Using @@ERROR
- @@ERROR (Transact-SQL)\
Manage transactions
- Transactions
- Controlling Transactions (Database Engine)
- Explicit Transactions
- Implicit Transactions
- Autocommit Transactions
- Distributed Transactions (Database Engine)
BEGIN TRANSACTION
- Explicit Transactions
- BEGIN TRANSACTION (Transact-SQL)
COMMIT
- Explicit Transactions
- COMMIT TRANSACTION (Transact-SQL)
- COMMIT WORK (Transact-SQL)
ROLLBACK
- Explicit Transactions
- ROLLBACK TRANSACTION (Transact-SQL)
- ROLLBACK WORK (Transact-SQL)
SET TRANSACTION ISOLATION LEVEL
- Customizing Transaction Isolation Level
- Isolation Levels in the Database Engine
- Adjusting Transaction Isolation Levels
- SET TRANSACTION ISOLATION LEVEL

MCTS - Microsoft SQL Server 2008, Database Development - 70-433 - Objective List Part 1 (Implementing Tables and Views)

kanasz.robert — Wed, 02 Nov 2011 12:17:52 GMT

MCTS .NET Application Development Foundation - 70-536 – Objectives List Part 7 (Implementing globalization, drawing, and text manipulation functionality in a .NET Framework application)

kanasz.robert — Fri, 28 Oct 2011 12:37:00 GMT

Format data based on culture information.

Enhance the user interface of a .NET Framework application by using brushes, pens, colors, and fonts.

Enhance the user interface of a .NET Framework application by using graphics, images, bitmaps, and icons.

Enhance the user interface of a .NET Framework application by using shapes and sizes.

Enhance the text handling capabilities of a .NET Framework application (refer System.Text namespace), and search, modify, and control text in a .NET Framework application by using regular expressions.