using System;
 
namespace TestBase64
{
  /// <summary>
 
  /// Summary description for Base64Encoder.
 
  /// </summary>
 
  public class Base64Encoder
  {
    byte[] source;
    int length,length2;
    int blockCount;
    int paddingCount;
    public Base64Encoder(byte[] input)
    {
      source=input;
      length=input.Length;
      if((length % 3)==0)
      {
        paddingCount=0;
        blockCount=length/3;
      }
      else
      {
        paddingCount=3-(length % 3);//need to add padding
 
        blockCount=(length+paddingCount) / 3;
      }
      length2=length+paddingCount;//or blockCount *3
 
    }
 
    public char[] GetEncoded()
    {
      byte[] source2;
      source2=new byte[length2];
      //copy data over insert padding
 
      for (int x=0; x<length2;x++)
      {
        if (x<length)
        {
          source2[x]=source[x];
        }
        else
        {
          source2[x]=0;
        }
      }
 
      byte b1, b2, b3;
      byte temp, temp1, temp2, temp3, temp4;
      byte[] buffer=new byte;
      char[] result=new char;
      for (int x=0;x<blockCount;x++)
      {
        b1=source2[x*3];
        b2=source2[x*3+1];
        b3=source2[x*3+2];
 
        temp1=(byte)((b1 & 252)>>2);//first
 
 
        temp=(byte)((b1 & 3)<<4);
        temp2=(byte)((b2 & 240)>>4);
        temp2+=temp; //second
 
 
        temp=(byte)((b2 & 15)<<2);
        temp3=(byte)((b3 & 192)>>6);
        temp3+=temp; //third
 
 
        temp4=(byte)(b3 & 63); //fourth
 
 
        buffer[x*4]=temp1;
        buffer[x*4+1]=temp2;
        buffer[x*4+2]=temp3;
        buffer[x*4+3]=temp4;
 
      }
 
      for (int x=0; x<blockCount*4;x++)
      {
        result[x]=sixbit2char(buffer[x]);
      }
 
      //covert last "A"s to "=", based on paddingCount
 
      switch (paddingCount)
      {
        case 0:break;
        case 1:result='=';break;
        case 2:result='=';
          result='=';
          break;
        default:break;
      }
      return result;
    }
 
    private char sixbit2char(byte b)
    {
      char[] lookupTable=new char[64]
          {  'A','B','C','D','E','F','G','H','I','J','K','L','M',
            'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
            'a','b','c','d','e','f','g','h','i','j','k','l','m',
            'n','o','p','q','r','s','t','u','v','w','x','y','z',
            '0','1','2','3','4','5','6','7','8','9','+','/'};
 
      if((b>=0) &&(b<=63))
      {
        return lookupTable[(int)b];
      }
      else
      {
        //should not happen;
 
        return ' ';
      }
    }
  }
}

using System;
 
namespace TestBase64
{
  /// <summary>
 
  /// Summary description for Base64Decoder.
 
  /// </summary>
 
  public class Base64Decoder
  {
    char[] source;
    int length, length2, length3;
    int blockCount;
    int paddingCount;
    public Base64Decoder(char[] input)
    {
      int temp=0;
      source=input;
      length=input.Length;
 
      //find how many padding are there
 
      for (int x=0;x<2;x++)
      {
        if(input[length-x-1]=='=')
          temp++;
      }
      paddingCount=temp;
      //calculate the blockCount;
 
      //assuming all whitespace and carriage returns/newline were removed.
 
      blockCount=length/4;
      length2=blockCount*3;
    }
 
    public byte[] GetDecoded()
    {
      byte[] buffer=new byte[length];//first conversion result
 
      byte[] buffer2=new byte[length2];//decoded array with padding
 
 
      for(int x=0;x<length;x++)
      {
        buffer[x]=char2sixbit(source[x]);
      }
 
      byte b, b1,b2,b3;
      byte temp1, temp2, temp3, temp4;
 
      for(int x=0;x<blockCount;x++)
      {
        temp1=buffer[x*4];
        temp2=buffer[x*4+1];
        temp3=buffer[x*4+2];
        temp4=buffer[x*4+3];        
 
        b=(byte)(temp1<<2);
        b1=(byte)((temp2 & 48)>>4);
        b1+=b;
 
        b=(byte)((temp2 & 15)<<4);
        b2=(byte)((temp3 & 60)>>2);
        b2+=b;
 
        b=(byte)((temp3 & 3)<<6);
        b3=temp4;
        b3+=b;
 
        buffer2[x*3]=b1;
        buffer2[x*3+1]=b2;
        buffer2[x*3+2]=b3;
      }
      //remove paddings
 
      length3=length2-paddingCount;
      byte[] result=new byte[length3];
 
      for(int x=0;x<length3;x++)
      {
        result[x]=buffer2[x];
      }
 
      return result;
    }
 
    private byte char2sixbit(char c)
    {
      char[] lookupTable=new char[64]
          {  
 
    'A','B','C','D','E','F','G','H','I','J','K','L','M','N',
    'O','P','Q','R','S','T','U','V','W','X','Y', 'Z',
    'a','b','c','d','e','f','g','h','i','j','k','l','m','n',
    'o','p','q','r','s','t','u','v','w','x','y','z',
    '0','1','2','3','4','5','6','7','8','9','+','/'};
      if(c=='=')
        return 0;
      else
      {
        for (int x=0;x<64;x++)
        {
          if (lookupTable[x]==c)
            return (byte)x;
        }
        //should not reach here
 
        return 0;
      }
 
    }
 
  }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
namespace 事件委托2
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
            Form1.myevent += new Form1.mydelegate(fm2_myevent);
 
        }
        void fm2_myevent(string str)
        { 
 
            this.listBox1.Items.Add(str);
 
        }
 
        private void Form2_Load(object sender, EventArgs e)
        {
 
        }
       private  void Form2_Click(object sender, System.EventArgs e)
        {
 
            MessageBox.Show("大家好");
        }
 
        private void SDSJ_Shown(object sender, EventArgs e)
        {
            MessageBox.Show("你好");
        }
        private void Form2_LocationChanged(object sender, EventArgs e)
        {
 
        }
    }
}

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Linq; 
using System.Text; 
using System.Windows.Forms; 
namespace 事件委托2 
{ 
     public partial class Form1 : Form 
     { 
	Form2 frm = new Form2(); 
	public Form1() 
        { 
           InitializeComponent(); 
           frm.Show(); 
           frm.Hide(); 
        } 
        public delegate void mydelegate(string text);//定义一个委托  
        public static event mydelegate myevent; 
        private void listBox1_MouseDoubleClick(object sender, MouseEventArgs e) 
        { 
           if (myevent != null) 
           { 
               myevent(this.listBox1.SelectedItem.ToString()); 
           } 
        } 
        private void button1_Click(object sender, EventArgs e) 
        { 
            frm.Show(); 
        } 
     } 
}

string value = "Wed Jan 06 17:08:03 +0000 2010"; 
//分割出年、月、日、分、秒、时、星期 
string[] date=value.Split(new char[]{' ',':'},StringSplitOptions.RemoveEmptyEntries); 
//生成本地日期字符串格式,GMT代表根据本地时区日期计算 
string datestr = string.Format("{0}, {1} {2} {3} {4}:{5}:{6} GMT", date[0], date[2], date[1], date[7], date[3], date[4], date[5]); 
//转换成本地日期 //实际日期就出来了，是 星期四, 2010-01-07 01:08:03
 
DateTime dtt = Convert.ToDateTime(datestr);
//在处理相关的时间的时候,下面代码就能实现了.
DateTime now = DateTime.Now;
TimeSpan ts = (TimeSpan)now.Subtract(dtt);
int xday = ts.Days;//获取相差天数
int xhour = ts.Hours;//相差小时
int xmin = ts.Minutes;//相差分钟
int xsec = ts.Seconds;//相差秒数
//相差时间结果
string xTime = string.Format("时间相差{0}天{1}小时{2}分{3}秒",xday,xhour,xmin,xsec);

private static string[][] TimeZones = new string[][] 
{
            new string[] {"ACDT", "+1030", "Australian Central Daylight"},
            new string[] {"ACST", "+0930", "Australian Central Standard"},
            new string[] {"ADT", "-0300", "(US) Atlantic Daylight"},
            new string[] {"AEDT", "+1100", "Australian East Daylight"},
            new string[] {"AEST", "+1000", "Australian East Standard"},
            new string[] {"AHDT", "-0900", ""},
            new string[] {"AHST", "-1000", ""},
            new string[] {"AST", "-0400", "(US) Atlantic Standard"},
            new string[] {"AT", "-0200", "Azores"},
            new string[] {"AWDT", "+0900", "Australian West Daylight"},
            new string[] {"AWST", "+0800", "Australian West Standard"},
            new string[] {"BAT", "+0300", "Bhagdad"},
            new string[] {"BDST", "+0200", "British Double Summer"},
            new string[] {"BET", "-1100", "Bering Standard"},
            new string[] {"BST", "-0300", "Brazil Standard"},
            new string[] {"BT", "+0300", "Baghdad"},
            new string[] {"BZT2", "-0300", "Brazil Zone 2"},
            new string[] {"CADT", "+1030", "Central Australian Daylight"},
            new string[] {"CAST", "+0930", "Central Australian Standard"},
            new string[] {"CAT", "-1000", "Central Alaska"},
            new string[] {"CCT", "+0800", "China Coast"},
            new string[] {"CDT", "-0500", "(US) Central Daylight"},
            new string[] {"CED", "+0200", "Central European Daylight"},
            new string[] {"CET", "+0100", "Central European"},
            new string[] {"CST", "-0600", "(US) Central Standard"},
            new string[] {"CENTRAL", "-0600", "(US) Central Standard"},
            new string[] {"EAST", "+1000", "Eastern Australian Standard"},
            new string[] {"EDT", "-0400", "(US) Eastern Daylight"},
            new string[] {"EED", "+0300", "Eastern European Daylight"},
            new string[] {"EET", "+0200", "Eastern Europe"},
            new string[] {"EEST", "+0300", "Eastern Europe Summer"},
            new string[] {"EST", "-0500", "(US) Eastern Standard"},
            new string[] {"EASTERN", "-0500", "(US) Eastern Standard"},
            new string[] {"FST", "+0200", "French Summer"},
            new string[] {"FWT", "+0100", "French Winter"},
            new string[] {"GMT", "-0000", "Greenwich Mean"},
            new string[] {"GST", "+1000", "Guam Standard"},
            new string[] {"HDT", "-0900", "Hawaii Daylight"},
            new string[] {"HST", "-1000", "Hawaii Standard"},
            new string[] {"IDLE", "+1200", "Internation Date Line East"},
            new string[] {"IDLW", "-1200", "Internation Date Line West"},
            new string[] {"IST", "+0530", "Indian Standard"},
            new string[] {"IT", "+0330", "Iran"},
            new string[] {"JST", "+0900", "Japan Standard"},
            new string[] {"JT", "+0700", "Java"},
            new string[] {"MDT", "-0600", "(US) Mountain Daylight"},
            new string[] {"MED", "+0200", "Middle European Daylight"},
            new string[] {"MET", "+0100", "Middle European"},
            new string[] {"MEST", "+0200", "Middle European Summer"},
            new string[] {"MEWT", "+0100", "Middle European Winter"},
            new string[] {"MST", "-0700", "(US) Mountain Standard"},
            new string[] {"MOUNTAIN", "-0700", "(US) Mountain Standard"},
            new string[] {"MT", "+0800", "Moluccas"},
            new string[] {"NDT", "-0230", "Newfoundland Daylight"},
            new string[] {"NFT", "-0330", "Newfoundland"},
            new string[] {"NT", "-1100", "Nome"},
            new string[] {"NST", "+0630", "North Sumatra"},
            new string[] {"NZ", "+1100", "New Zealand "},
            new string[] {"NZST", "+1200", "New Zealand Standard"},
            new string[] {"NZDT", "+1300", "New Zealand Daylight "},
            new string[] {"NZT", "+1200", "New Zealand"},
            new string[] {"PDT", "-0700", "(US) Pacific Daylight"},
            new string[] {"PST", "-0800", "(US) Pacific Standard"},
            new string[] {"PACIFIC", "-0800", "(US) Pacific Standard"},
            new string[] {"ROK", "+0900", "Republic of Korea"},
            new string[] {"SAD", "+1000", "South Australia Daylight"},
            new string[] {"SAST", "+0900", "South Australia Standard"},
            new string[] {"SAT", "+0900", "South Australia Standard"},
            new string[] {"SDT", "+1000", "South Australia Daylight"},
            new string[] {"SST", "+0200", "Swedish Summer"},
            new string[] {"SWT", "+0100", "Swedish Winter"},
            new string[] {"USZ3", "+0400", "USSR Zone 3"},
            new string[] {"USZ4", "+0500", "USSR Zone 4"},
            new string[] {"USZ5", "+0600", "USSR Zone 5"},
            new string[] {"USZ6", "+0700", "USSR Zone 6"},
            new string[] {"UT", "-0000", "Universal Coordinated"},
            new string[] {"UTC", "-0000", "Universal Coordinated"},
            new string[] {"UZ10", "+1100", "USSR Zone 10"},
            new string[] {"WAT", "-0100", "West Africa"},
            new string[] {"WET", "-0000", "West European"},
            new string[] {"WST", "+0800", "West Australian Standard"},
            new string[] {"YDT", "-0800", "Yukon Daylight"},
            new string[] {"YST", "-0900", "Yukon Standard"},
            new string[] {"ZP4", "+0400", "USSR Zone 3"},
            new string[] {"ZP5", "+0500", "USSR Zone 4"},
            new string[] {"ZP6", "+0600", "USSR Zone 5"}
        };
}

in_reply_to_screen_name:value,
source:value,
geo:value,
truncated:value,
user:{
     item1:value,
     item2:value,
}

public class Tweet
{
        private string _in_reply_to_screen_name;
        private string _source;
        private string _geo;
        private string _truncated;
        private TweetUser _user;
 
        public string in_reply_to_screen_name
        {
            set { this._in_reply_to_screen_name = value; }
            get { return this._in_reply_to_screen_name; }
        }
        public string source
        {
            set { this._source = value; }
            get { return this._source; }
        }
        public string geo
        {
            get { return this._geo; }
            set { this._geo = value; }
        }
        public string truncated
        {
            set { this._truncated = value; }
            get { return this._truncated; }
        }
        public TweetUser user
        {
            set { this._user = value; }
            get { return this._user; }
        }
}
//根据JSON内的USER的数目来生成相对的对象.
 public class TweetUser
 {
        private string _item1;
        public string item1
        {
            get { }
            set { }
        }
}
//然后构造一个List
public class Tweets:List<Tweet> {}
//这样在前台处理的时候, 就可以直接使用Newtonsoft类来处理了.
Tweets tweets = JsonConvert.DeserializeObject<Tweets>(strJSONValue);

//这个class是定义在xbap窗体应用程序中的, 如果想写在单独的类里面也可以,但要注意引用命名空间.
//这里重载2个方法, 从数据源到值转换Convert,
//和从值到数据源的转换ConvertBack 
 public class AgeToForcegroundConverter : IValueConverter
 {
   public object Convert(object value, Type targettype, object obj, System.Globalization.CultureInfo info)
   {
        if (targettype != typeof(Brush)) { return null; }
        int age = int.Parse(value.ToString());
        return (age > 25 ? Brushes.Red : Brushes.Green);
   }
   public object ConvertBack(object value, Type targettype, object obj, System.Globalization.CultureInfo info)
   {
         throw new NotImplementedException();
         //return value;
     }
}

<Window    
xmlns:local ="clr-namespace:命名空间"    //这一行是定义Windows.Resoures的local标签. 
/>
这里是定义一个转换器
<Window.Resources>
    <local:AgeToForcegroundConverter x:Key="ageConverter"></local:AgeToForcegroundConverter>
</Window.Resources>
<!--这里就是具体的绑定的方法了, 要注意转换器的返回和绑定的属性匹配, 如果是文本型,则绑定tex属性之类.-->
 <TextBox Name="ageTextBox" Foreground="{Bind Path=Age,Converter={StaticResource ageConverter}}" />
<!-- ... ...  -->
<!-- 同样,可以将另一个元素的属性直接与其它控件绑定绑定. 这样当Textbox发生变化, 按钮也会发生变化.-->
<Button Forceground="{Binding Path=Forceground, ElementName=agetTextBox}">

using System.ComponentModel;//命名空间的引用
public class Person :INotifyPropertyChanged //定义一个人, 让其继承自INotifyPropertyChanged的类.
{
        //PropertyChangedEventHandler属于INotifyPropertyChanged的成员, 这里我们拿来使用.
        public event PropertyChangedEventHandler PropertyChanged;
       //定义处理方法, 当成员发生变化的时候发生的时候,用来通知WPF进行处理.
        protected void Notify(string propName)
        {
            if (this.PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propName));
            }
        }
        string name;
        public string Name 
        {
            get { return this.name; }
            set { this.name = value; }
        }
        int age;
        public int Age
        {
            get { return this.age; }
            set
            {
                if (this.age == value) return;
                else this.age = value;
                Notify("Age");
            }
        }
        public Person() { }
        public Person(string name, int age)
        {
            this.age = age;
            this.name = name;
        }
 
}

    <Grid>
        <TextBox Height="23" Margin="74,87,84,0" Name="txtName" VerticalAlignment="Top" />
        <TextBox Height="23" Margin="74,0,84,107" Name="txtAge" VerticalAlignment="Bottom" />
        <Button Height="23" Margin="74,0,130,78" Name="btnClick" VerticalAlignment="Bottom" Click="btnClick_Click">Button</Button>
    </Grid>

 public partial class Example : Window
 {
        Person person = new Person("Steven", 25); //这个都知道,就不用说了.
        public Example()
        {
            InitializeComponent();
            this.txtName.Text = person.Name;
            this.txtAge.Text  = person.Age.ToString();
            //由于person继承自INotifyPropertyChanged这个类, 所以我们也可以给他注册一个事件.
           //用于告诉WPF是哪一个成员的值发生了变化. 
           //这里其于值的变化来触发事件,而不根据按钮事件或者是文本框的TextBox Changed来触发事件
            person.PropertyChanged +=new System.ComponentModel.PropertyChangedEventHandler(person_PropertyChanged);
 
        }
        //当按钮按下时, 由于person.Age的值发生了变化, 因此,e.PropertyName的值就是person中的Age属性.
        //根据switch判断, 可知结果.
        void person_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            switch (e.PropertyName)
            { 
                case "Name":
                    this.txtName.Text = person.Name;
                    break;
                case "Age":
                    this.txtAge.Text = person.Age.ToString();
                    break;
            }
        }
 
        private void btnClick_Click(object sender, RoutedEventArgs e)
        {
            ++person.Age;
            MessageBox.Show(person.Name + person.Age.ToString());
        }
 }

  <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition></ColumnDefinition>
            <ColumnDefinition></ColumnDefinition>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <TextBlock Grid.Column="0" Grid.Row="0">Cell1</TextBlock>
        <TextBlock Grid.Column="1" Grid.Row="0">Cell2</TextBlock>
        <TextBlock Grid.Column="0" Grid.Row="1">Cell3</TextBlock>
        <TextBlock Grid.Column="1" Grid.Row="1">Cell4</TextBlock>
        <TextBlock Grid.Column="0" Grid.Row="2">Cell5</TextBlock>
        <TextBlock Grid.Column="1" Grid.Row="2">Cell6</TextBlock>
    </Grid>