Scribd
Upload
69 views26 pages

More C: Web Application Development Faculty of Mathematics and Computer Science University of Bucharest

The document discusses advanced C# features such as attributes, preprocessor directives, XML comments, and unsafe code. Attributes allow adding metadata to code elements. Preprocessor directives include conditional compilation. XML comments allow embedding documentation in source code that is compiled into documentation files. Unsafe code allows using pointers and unsafe operations for performance or interoperability with native code.

Uploaded by

Andrei Sipoș
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
69 views26 pages

More C: Web Application Development Faculty of Mathematics and Computer Science University of Bucharest

The document discusses advanced C# features such as attributes, preprocessor directives, XML comments, and unsafe code. Attributes allow adding metadata to code elements. Preprocessor directives include conditional compilation. XML comments allow embedding documentation in source code that is compiled into documentation files. Unsafe code allows using pointers and unsafe operations for performance or interoperability with native code.

Uploaded by

Andrei Sipoș
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 26

#

More C

Web Application Development

Faculty of Mathematics
and Computer Science
University of Bucharest
Prerequisites
 This module assumes that you understand the
fundamentals of
 Programming
 Variables, statements, functions, loops, etc.
 Object-oriented programming
 Classes, inheritance, polymorphism,
members, etc.
 C++ or Java
 Introduction to C#
 Object-Oriented Concepts in C#
Learning Objectives
 Learn advanced features of the C# language
Agenda
 Attributes
 Preprocessor Directives
 XML Comments
 Unsafe Code
Attributes
Overview

 It’s often necessary to associate information


(metadata) with types and members, e.g.
 Documentation URL for a class
 Transaction context for a method
 XML persistence mapping
 COM ProgID for a class
 Attributes allow you to decorate a code element
(assembly, module, type, member, return value
and parameter) with additional information
Attributes
Overview

[HelpUrl(“http://SomeUrl/APIDocs/SomeClass”)]
class SomeClass {
[Obsolete(“Use SomeNewMethod instead”)]
public void SomeOldMethod() {
...
}

public string Test([SomeAttr()] string param1) {


...
}
}
Attributes
Overview
 Attributes are superior to the alternatives
 Modifying the source language
 Using external files, e.g., .IDL, .DEF
 Attributes are extensible
 Attributes allow to you add information not supported
by C# itself
 Not limited to predefined information
 Built into the .NET Framework, so they work
across all .NET languages
 Stored in assembly metadata
Attributes
Overview
 Some predefined .NET Framework attributes

Attribute Name Description


Should a property or event be displayed in
Browsable
the property window
Serializable Allows a class or struct to be serialized

Obsolete Compiler will complain if target is used

ProgId COM Prog ID

Transaction Transactional characteristics of a class


Attributes
Overview
 Attributes can be
 Attached to types and members
 Examined at run-time using reflection
 Completely extensible
 Simply a class that inherits from System.Attribute
 Type-safe
 Arguments checked at compile-time
 Extensive use in .NET Framework
 XML, Web Services, security, serialization,
component model, COM and P/Invoke interop,
code configuration…
Attributes
Querying Attributes

[HelpUrl("http://SomeUrl/MyClass")]
class Class1 {}
[HelpUrl("http://SomeUrl/MyClass"),
HelpUrl("http://SomeUrl/MyClass”, Tag=“ctor”)]
class Class2 {}

Type type = typeof(MyClass);


foreach (object attr in type.GetCustomAttributes() )
{
if ( attr is HelpUrlAttribute ) {
HelpUrlAttribute ha = (HelpUrlAttribute) attr;
myBrowser.Navigate( ha.Url );
}
}
Agenda
 Attributes
 Preprocessor Directives
 XML Comments
 Unsafe Code
Preprocessor Directives
Overview

 C# provides preprocessor directives that serve a


number of functions
 Unlike C++, there is not a separate preprocessor
 The “preprocessor” name is preserved only for
consistency with C++
 C++ preprocessor features removed include:
 #include: Not really needed with one-stop
programming; removal results in faster compilation
 Macro version of #define: removed for clarity
Preprocessor Directives
Overview

Directive Description
#define, #undef Define and undefine conditional symbols

#if, #elif, #else, #endif Conditionally skip sections of code

#error, #warning Issue errors and warnings

#region, #end Delimit outline regions

#line Specify line number


Preprocessor Directives
Conditional Compilation

#define Debug
public class Debug {
[Conditional("Debug")]
public static void Assert(bool cond, String s) {
if (!cond) {
throw new AssertionException(s);
}
}
void DoSomething() {
...
// If Debug is not defined, the next line is
// not even called
Assert((x == y), “X should equal Y”);
...
}
}
Preprocessor Directives
Assertions

 By the way, assertions are an incredible way to


improve the quality of your code
 An assertion is essentially a unit test built right
into your code
 You should have assertions to test
preconditions, postconditions and invariants
 Assertions are only enabled in debug builds
 Your code is QA’d every time it runs
Preprocessor Directives
Assertions

 See System.Diagnostics.Debug.Assert
 See http://www.nunit.org
 Must read: “Writing Solid Code”, by Steve
Maguire, Microsoft Press, ISBN 1-55615-551-4
Agenda
 Attributes
 Preprocessor Directives
 XML Comments
 Unsafe Code
XML Comments
Overview
 Programmers don’t like to document code, so we need a
way to make it easy for them to produce quality,
up-to-date documentation
 C# lets you embed XML comments that document types,
members, parameters, etc.
 Denoted with triple slash: ///
 XML document is generated when code is compiled
with /doc argument
 Comes with predefined XML schema, but you can add
your own tags too
 Some are verified, e.g. parameters, exceptions, types
XML Comments
Overview

XML Tag Description


<summary>, <remarks> Type or member
<param> Method parameter
<returns> Method return value
<exception> Exceptions thrown from method
<example>, <c>, <code> Sample code
<see>, <seealso> Cross references
<value> Property
<paramref> Use of a parameter
<list>, <item>, ... Formatting hints
<permission> Permission requirements
XML Comments
Overview

class XmlElement {
/// <summary>
/// Returns the attribute with the given name and
/// namespace</summary>
/// <param name="name">
/// The name of the attribute</param>
/// <param name="ns">
/// The namespace of the attribute, or null if
/// the attribute has no namespace</param>
/// <return>
/// The attribute value, or null if the attribute
/// does not exist</return>
/// <seealso cref="GetAttr(string)"/>
///
public string GetAttr(string name, string ns) {
...
}
}
Agenda
 Attributes
 Preprocessor Directives
 XML Comments
 Unsafe Code
Unsafe Code
Overview
 Developers sometime need total control
 Performance extremes
 Dealing with existing binary structures
 Existing code
 Advanced COM support, DLL import
 C# allows you to mark code as unsafe, allowing
 Pointer types, pointer arithmetic
 ->, * operators
 Unsafe casts
 No garbage collection
Unsafe Code
Overview
 Lets you embed native C/C++ code
 Basically “inline C”
 Must ensure the GC doesn’t move your data
 Use fixed statement to pin data
 Use stackalloc operator so memory is allocated
on stack, and need not be pinned

unsafe void Foo() {


char* buf = stackalloc char[256];
for (char* p = buf; p < buf + 256; p++) *p =
0;
...
}
Unsafe Code
Overview
class FileStream: Stream {
int handle;

public unsafe int Read(byte[] buffer, int index,


int count) {
int n = 0;
fixed (byte* p = buffer) {
ReadFile(handle, p + index, count, &n, null);
}
return n;
}

[dllimport("kernel32", SetLastError=true)]
static extern unsafe bool ReadFile(int hFile,
void* lpBuffer, int nBytesToRead,
int* nBytesRead, Overlapped* lpOverlapped);
}
Unsafe Code
C# and Pointers

 Power comes at a price!


 Unsafe means unverifiable code
 Stricter security requirements
 Before the code can run
 Downloading code
Conclusion
 Attributes
 Preprocessor Directives
 XML Comments
 Unsafe Code

You might also like