asp.net source code blog

Sometimes you may have strings to represent dates (ex. 20100102 that represents 2010 January 2), here's an example how it can be converted to DateTime:

string dtString = "20100102";

IFormatProvider culture = new CultureInfo("en-EN", false);

DateTime dt = DateTime.ParseExact(dtString, "yyyyMMdd", culture, DateTimeStyles.NoCurrentDateDefault);

Now, if you want to convert DateTime variable to string in the format above, here's an example how it can be done:

String dtNewString = String.Format("{0:dd/MM/yyyy}", dt);

Here's a simple example how you can detect URLs in some text and replace them with html code for hyperlinks:

string someText = "here's a simple text that contains urls in it like http://www.aspnetsource.com or http://aspnetsource.com or http://aspnetsource.com";

// we create a Regex object with pattern to detect URLs
Regex reg = new Regex(@"((http|https|ftp|gopher|telnet|file|notes|ms-help):((//)|(\\\\))*[\w\d:#@%/;$()~_?\+-=\\\.&]*)");

string htmText = reg.Replace(someText, "<a href=\"$1\">$1</a>");

/* now htmlText contains formatted html code with hrefs:

here's a simple text that contains urls in it like <a href="http://www.aspnetsource.com">http://www.aspnetsource.com</a> or <a href="http://aspnetsource.com">http://aspnetsource.com</a> or <a href="http://aspnetsource.com">http://aspnetsource.com</a>

*/

In my work I had to concatenate two byte arrays but,
unfortunately, it seems that there's no elegant way to do
concat of two byte arrays in "C#" :(

I'd offer you a suggestion for doing it,
just copy-paste this simpe function in your project:

public byte[] ConcatByteArrays(byte[] a, int aSize, byte[] b, int bSize)
{
byte[] buff = new byte[aSize + bSize];
for(int i=0; i<aSize; i++)
buff[i] = a[i];
for(int i=0; i<bSize; i++)
buff[i+aSize] = b[i];
return buff;
}

Maybe, you wonder which is better choice: "try/catch" or "using" ?

well, it seem that they're really different from each other:

The "using" statement could be useful in:

1. Whenever an exception occurs, the using block takes care of closing connections like database connections, IO connections etc.
2. It also safely disposes the relevant objects

Note*: Only objects that implement IDisposable interface can be used in Using block!

The "try/catch" is used for any error occurred you can catch and display the message to the user.

So, I think the best answer of the question is: Use both of them:

using (OdbcConnection conn = new OdbcConnection(connectionString))
{
       try
       {
              dadapter.SelectCommand.Connection = conn;
               
              OdbcCommandBuilder builder = new OdbcCommandBuilder( dadapter );

              conn.Open();
              dadapter.Update(dset, "payunit");
         }
         catch ( Exception ex )
         {
                  //  exception handling code.    
         }
         finally
         {
                 conn.Close();
         }
   }      //  conn object is disposed. 

Here's list of new features of C# language in Framework 3.0.

1. Implicitly Typed Local Variables

You can use implicitly-typed local variables to store anonymous types. You can also use them in any other situation in which you want the compiler to determine the type of a local variable (in other words a variable declared at method scope). The following examples show how to use implicitly typed variables in both scenarios.

var developerNames =
from developer in developers
where developer.Language.Equals("C#")
select developer.FirstName + " " + developer.LastName;

foreach (string str in developerNames)
{
Console.WriteLine(str);
}

2. Implicitly Typed Arrays

You can also create an implicitly-typed array in which the type of the array instance is inferred from the elements specified in the array initializer. The rules for any implicitly-typed variable also apply to implicitly-typed arrays.

var ourSite = new[] { "asp", "net", "source", ".", "com" };

3. Auto-Implemented Properties

Auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors.

public class Developer
{
public string Language { get; set; }
public string Name { get; set; }
}

4. Additional Object Initializers Way

You can initialize new objects in easiest way:

...

Developer dev = new Developer { Language = "C#", Name = "Ivanov" };

5. Additional Arrays and Collections Initializers Way

Developer[] devs = new Developer[] {
new Developer { Language = "C#", Name = "Tihomir" },
new Developer { Language = "VB.NET", Name = "Ivanov" }
};

6. Extension Methods

Now you can "add" methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type. Extension methods are a special kind of static method, but they are called as if they were instance methods on the extended type.

public static bool IsDotNetDeveloper(this Developer dev)
{
return dev.Language.Equals("C#") || dev.Language.Equals("VB.NET");
}

...

Developer dev = new Developer { Language = "C#", Name = "Ivanov" };

bool isDotNet = dev.IsDotNetDeveloper();

7. Anonymous types

Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without having to first explicitly define a type. The type name is generated by the compiler and is not available at the source code level.

var v = new { Language1 = "C#", Language2 = "VB.NET" };

8. Lambda Expressions

When '=>' is used that's lambda operator. It is used in lambda expressions to separate the input variables on the left side from the lambda body on the right side. Lambda expressions are inline expressions similar to anonymous methods but more flexible.

string[] languages = { "C++", "C#", "VB.NET" };

int min = languages.Min(l => l.Length);

9. Query Keywords

- from - Specifies a data source and a range variable (similar to an iteration variable).

- where - Filters source elements based on one or more Boolean expressions separated by logical AND and OR operators ( && or || ).

   select - Specifies the type and shape that the elements in the returned sequence will have when the query is executed.

   group - Groups query results according to a specified key value.

   into - Provides an identifier that can serve as a reference to the results of a join, group or select clause.

   orderby - Sorts query results in ascending or descending order based on the default comparer for the element type.

   join - Joins two data sources based on an equality comparison between two specified matching criteria.

   let - Introduces a range variable to store sub-expression results in a query expression.

string[] languages = { "C++", "C#", "VB.NET" };

var dotnets = from lang in languages
where lang.Equals("C#") || lang.Equals("VB.NET")
select lang;

foreach (var dotnet in dotnets)
{
Console.WriteLine(dotnets);
}

10. Partial Method

A partial method has its signature defined in one part of a partial type, and its implementation defined in another part of the type. Partial methods enable class designers to provide method hooks, similar to event handlers, that developers may decide to implement or not. If the developer does not supply an implementation, the compiler removes the signature at compile time.

partial class YourClass
{
  partial void SomeMethod(int i);
}

// This part can be in a separate file.
partial class YourClass
{
  // Comment out this method and the program
  // will still compile.
  partial void SomeMethod(int i)
  {
    Console.WriteLine("AspNetSource.com visit #{0}", i);
  }
}

That's All. Happy Coding :)

Unfortunately, method Guid.TryParse(string s, out Guid result) doesn't exist in .net, event in Framework 3.5 :(

But it's easy to write our method which tries to parse Guid:

Example 1:

bool TryParseGuid(string s, out Guid result)
{
 bool parseResult = false; 
 result = Guid.Empty; 
 try
 {
  result = new Guid(s);
  parseResult = true;
 }
 catch (Exception)
 {}
 return parseResult;
}

First example work but it looks little 'ugly', so this method could be written in more intelligent way:

Example 2:

public bool GuidTryParse(string s, out Guid result)
{
 bool parseResult = false;
 result = Guid.Empty;
 if (!string.IsNullOrEmpty(s))
 {
  Regex format = new Regex(
   "^[A-Fa-f0-9]{32}$|" +
   "^({|\\()?[A-Fa-f0-9]{8}-([A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}(}|\\))?$|" +
   "^({)?[0xA-Fa-f0-9]{3,10}(, {0,1}[0xA-Fa-f0-9]{3,6}){2}, {0,1}({)([0xA-Fa-f0-9]{3,4}, {0,1}){7}[0xA-Fa-f0-9]{3,4}(}})$");
  Match match = format.Match(s);
  if (match.Success)
  {
   result = new Guid(s);
   parseResult = true;
  }
 }
 return parseResult;
}

That's all! Happy coding!

something very cool thing in asp.net developing with Visual Studio is the debugger: in QuickWatch you can write everyting: variables, call functions to see result by them, ... everything, ... Well, almost everything: in new debugger: you cannot see result of lambda expressions:

it's not big deal but until this moment I've used to 'quickwatching' everything, but now the debugging will be a little different :(

That's all! Happy coding!