// Demonstrate a using alias.
using System;
// Create an alias for Counter.CountDown.
using Count = Counter.CountDown;
// Declare a namespace for counters.
namespace Counter {
// A simple countdown counter.
class CountDown {
int val;
public CountDown(int n) {
val = n;
}
public void reset(int n) {
val = n;
}
public int count() {
if(val > 0) return val--;
else return 0;
}
}
}
public class NSDemo4 {
public static void Main() {
// Here, Count is used as a name for Counter.CountDown.
Count cd1 = new Count(10);
int i;
do {
i = cd1.count();
Console.Write(i + " ");
} while(i > 0);
Console.WriteLine();
Count cd2 = new Count(20);
do {
i = cd2.count();
Console.Write(i + " ");
} while(i > 0);
Console.WriteLine();
cd2.reset(4);
do {
i = cd2.count();
Console.Write(i + " ");
} while(i > 0);
Console.WriteLine();
}
}
Software Development
software development notes, main category for Cs, Java, and other programming experiences.
Using an alias to resolve ambiguity
/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa
Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/
// Alias.cs -- demonstrates using an alias to resolve ambiguity
//
// Compile this program with the following command line:
// C:>csc Alias.cs
using System;
using MsgBox = System.Windows.Forms.MessageBox;
using System.Timers;
namespace nsNamespaces
{
public class Alias
{
static Timer timer;
static public void Main ()
{
// Create the timer object.
timer = new Timer (2000);
// This is a one-shot timer. Set auto reset to false
timer.AutoReset = false;
// Assign the event handler method.
timer.Elapsed += new ElapsedEventHandler(ProcessTimerEvent);
// Start the timer.
timer.Start ();
// Wait for the timeout to occur.
MsgBox.Show ("Waiting for timer to expire", "Text");
}
// Timer event handler.
private static void ProcessTimerEvent (Object obj, ElapsedEventArgs e)
{
MsgBox.Show ("The timer has expired. Press "OK" " +
" to terminate the program",
"Timer Expired");
timer.Close ();
Environment.Exit (0);
}
}
}
Validates the zip code with regular expression
//Microsoft Public License (Ms-PL)
//http://c4fdevkit.codeplex.com/license
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
namespace C4F.DevKit.WebServices
{
/// <summary>
/// Provides useful methods like conversion methods.
/// </summary>
public static class Utility
{
/// <summary>
/// Validates the zip code
/// </summary>
/// <param name="zipCode">Zip code</param>
/// <returns>True if zip code is valid</returns>
public static bool ValidateZipCode(string zipCode)
{
if (String.IsNullOrEmpty(zipCode))
return false;
return Regex.IsMatch(zipCode, "(^[0-9]{5}$)|(^[0-9]{5}-[0-9]{4}$)");
}
}
}
Is valid url with regular expression
//The MIT License (MIT)
//http://arolibraries.codeplex.com/license
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
namespace AroLibraries.ExtensionMethods.Strings
{
public static class StringExt
{
public static bool Ext_IsValidUrl(this string text)
{
///Uri temp; return Uri.TryCreate(text);
Regex rx = new Regex(@"http(s)?://([w-]+.)+[w-]+(/[w- ./?%&=]*)?", RegexOptions.Compiled);
return rx.IsMatch(text);
}
}
}
Regular expression with For each and split
/*
Learning C#
by Jesse Liberty
Publisher: O'Reilly
ISBN: 0596003765
*/
using System;
using System.Text;
using System.Text.RegularExpressions;
namespace RegularExpressions
{
public class TesterRegularExpressions
{
public void Run()
{
string s1 =
"One,Two,Three Liberty Associates, Inc.";
Regex theRegex = new Regex(" |, |,");
StringBuilder sBuilder = new StringBuilder();
int id = 1;
foreach (string subString in theRegex.Split(s1))
{
sBuilder.AppendFormat(
"{0}: {1}
", id++, subString);
}
Console.WriteLine("{0}", sBuilder);
}
[STAThread]
static void Main()
{
TesterRegularExpressions t = new TesterRegularExpressions();
t.Run();
}
}
}
Provides static validation methods for strings.
//http://academicplanner.codeplex.com/
//Microsoft Public License (Ms-PL)
using System;
using System.Text.RegularExpressions;
namespace AcademicPlanner.Framework.Libraries.Validation
{
/// <summary>
/// Provides static validation methods for <c>string</c>s.
/// </summary>
/// <version>1.0</version>
/// <since>1.0</since>
public static class StringValidator
{
/// <summary>
/// Regular expression for a valid email address: "^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+-+)|([A-Za-z0-9]+.+)|([A-Za-z0-9]+++))*[A-Za-z0-9]+@((w+-+)|(w+.))*w{1,63}.[a-zA-Z]{2,6}$".
/// </summary>
/// <version>1.0</version>
/// <since>1.0</since>
public static readonly string EMAIL_REGEXP = @"^(([A-Za-z0-9]+_+)|([A-Za-z0-9]+-+)|([A-Za-z0-9]+.+)|([A-Za-z0-9]+++))*[A-Za-z0-9]+@((w+-+)|(w+.))*w{1,63}.[a-zA-Z]{2,6}$";
/// <summary>
/// Regular expression for words with letters only: "^([a-zA-Z]+s*)+$".
/// </summary>
/// <version>1.0</version>
/// <since>1.0</since>
public static readonly string ALPHA_REGEXP = @"^([a-zA-Z]+s*)+$";
/// <summary>
/// Regurlar expression for words with letters and digits and "_" only: "^([a-zA-Z0-9_]+s*)+$".
/// </summary>
/// <version>1.0</version>
/// <since>1.0</since>
public static readonly string ALNUM_REGEXP = @"^([a-zA-Z0-9_]+s*)+$";
/// <summary>
/// Checks whether the given <c>string</c> is blank or not i.e.
/// it contains at least one character.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <returns>Whether the <c>string</c> is blank or not.</returns>
/// <seealso cref="M:ContainsAtLeast"/>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool IsNotBlank(string pVal)
{
return ContainsAtLeast(pVal, 1);
}
/// <summary>
/// Checks whether the given <c>string</c> is a valid email address or not i.e.
/// it matches the <c>EMAIL_REGEXP</c> regualar expression.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <returns>Whether the <c>string</c> is a valid email address or not.</returns>
/// <seealso cref="M:Matches"/>
/// <seealso cref="P:EMAIL_REGEXP"/>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool IsEmailAddress(string pVal)
{
return Matches(pVal, EMAIL_REGEXP);
}
/// <summary>
/// Checks whether the given <c>string</c> matches the given regualar expression.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <param name="pRegex">The regular expression to check against.</param>
/// <returns>Whether the <c>string</c> matches the given regualar expression.</returns>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool Matches(string pVal, string pRegex)
{
return Regex.IsMatch(pVal, pRegex);
}
/// <summary>
/// Checks whether the given <c>string</c> is words with letters only i.e.
/// it matches the <c>ALPHA_REGEXP</c> regualar expression.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <returns>Whether the <c>string</c> is words with letters only or not.</returns>
/// <seealso cref="M:Matches"/>
/// <seealso cref="P:ALPHA_REGEXP"/>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool IsAlpha(string pVal)
{
return Matches(pVal, ALPHA_REGEXP);
}
/// <summary>
/// Checks whether the given <c>string</c> is words with letters and digits only i.e.
/// it matches the <c>ALNUM_REGEXP</c> regualar expression.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <returns>Whether the <c>string</c> is words with letters and digits only or not.</returns>
/// <seealso cref="M:Matches"/>
/// <seealso cref="P:ALNUM_REGEXP"/>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool IsAlphaNumeric(string pVal)
{
return Matches(pVal, ALNUM_REGEXP);
}
/// <summary>
/// Checks whether the given <c>string</c> contains at least the the given
/// number of characters.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <param name="pMinChars">The minimum number of characters the <c>string</c> should have.</param>
/// <returns>Whether the <c>string</c> contains at least the the given number of characters.</returns>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool ContainsAtLeast(string pVal, int pMinChars)
{
return (pVal.Trim().Length >= pMinChars);
}
/// <summary>
/// Checks whether the given <c>string</c> contains at most the the given
/// number of characters.
/// </summary>
/// <param name="pVal">The <c>string</c> to check.</param>
/// <param name="pMaxChars">The maximum number of characters the <c>string</c> should have.</param>
/// <returns>Whether the <c>string</c> contains at most the the given number of characters.</returns>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool ContainsAtMost(string pVal, int pMaxChars)
{
return (pVal.Trim().Length <= pMaxChars);
}
/// <summary>
/// Checks whether two <c>string</c>s are identical i.e. have the same characters
/// after trimming.
/// </summary>
/// <param name="pVal">The first <c>string</c>.</param>
/// <param name="pComparee">The second <c>string</c>.</param>
/// <returns>Whether the two <c>string</c>s are identical or not.</returns>
/// <version>1.0</version>
/// <since>1.0</since>
public static bool IsIdenticalTo(string pVal, string pComparee)
{
return pVal.Trim().Equals(pComparee.Trim());
}
}
}
Clean Telephone Number with Regular expression
///////////////////////////////////////////////////////////////////////////////////////////////
//
// This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
// Copyright (c) 2005-2008, Jim Heising
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation and/or
// other materials provided with the distribution.
//
// * Neither the name of Jim Heising nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.Xml;
namespace WOSI.Utilities
{
public class StringUtils
{
public static string CleanTelephoneNumber(string inputString)
{
return Regex.Replace(inputString, @"[()-.s]", "");
}
}
}