How To Switch an iPod from Mac to Windows | How To Do Things

How To Switch an iPod from Mac to Windows

By Tiffany Provost

When you first installed your iPod's formatting onto your computer, you either chose to go with a Mac or Windows operating system. This decision doesn't have to be a permanent one. This guide will show you just how simple it is to switch an iPod from a Mac to Windows, ensuring that you won't lose your mp3 music library in the process.

Step 1

Start by backing up all of your music. Over the time that you've had your iPod, you have probably transferred hundreds, if not thousands, of songs to your iPod from your iTunes music library. All of these songs are still available in your iTunes library though, should you ever need to access them again or transfer them a second time to your iPod. You wouldn't want to lose any of your precious mp3s while you are in the process of switching your iPod from Mac to Windows. So it's important to take the time to backup your mp3 collection. Save all of your songs to an external hard drive or copy them to a USB stick or CD before you proceed.

Step 2

Open iTunes and restore your iPod. Now that your music is backed up, you can begin to switch the operating system on your iPod. Allow iTunes to start and sync with your iPod (which should be attached to your PC with its USB cable at this point). Look for your iPod's name on the left side of the iTunes screen to ensure that your iPod is correctly connected. Now find the "Restore" button, click on it, and confirm your selection when the dialog box appears.

Now you'll need to wait a few moments while iTunes restores your iPod. When this process is complete, a message box will appear letting you know that iTunes will now restart your iPod. Once your iPod restarts, it should be reformatted to comply with the Windows operating system. Your iPod can now be used on a computer with a Windows operating system. (Surprisingly enough, many have found that a "restored" iPod still works on a Mac system even after reformatting it for a Windows system... weird.)

Step 3

Put your files back onto your iPod. Once you have successful switched your iPod from Mac to Windows, you'll want to sync all of your files back onto your mp3 player. If the computer doesn't do this automatically, just click on the "sync" button. You should notice that your iPod screen says "do not disconnect" if you have correctly done this.

If, for some reason, you can't seem to find your song files, fear not.  You backed them up, right? Just insert your backup storage device into your computer, copy the files back into your iTunes music library, and sync up your iPod again. Your songs should be available again in no time.

If you have any trouble when you try to switch an iPod from Mac to Windows, don't hesitate to call Apple's customer service and support desk for help.

via howtodothings.com

Posted via email from 米良的草窝

节前感言

千赶万赶～终于赶在国庆前把手头上的事情告一段落～

终于能够安安心心的回家过节～

快两个月了，终于有一天能够在晚上9点——加班的标准点离开公司～

明天就能回家了～很开心～

回家～多么温馨的一个说法～只有离开家～经历过风雨的孩子～才会深刻的理解家的含义～才能深刻的体会到回家这个词字面下的意思～

最近实在是太疲倦了～

心里上的，身体上的～

为的只是自己的一个信念～持续两个月每天加班到凌晨～

简直是一种疯狂的举动～

且不说心理的压力～当是身体上的疲劳就能把人累死～

再加上项目给人带来的心理压力～老板的敦促～同事合作上的摩擦…

不过这一切似乎都撑过来了～

是的～都撑过来了～

用事实证明自己～同时也宣告自己的存在～

不容易，但是我能做到～

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的草窝

神一般的一段代码～

收到Elevate(http://elevate.codeplex.com)项目里Pattern Match的启发，对它的实现进行了一些改进，于是写出了这样一段神一般的代码来～

不知道是不是有人能读懂段代码～

代码里把C#的Generic, Extension Method, Lambda Expression, Explicit Implemented Interface等Feature用到了极致～特别是Generic！

太神奇了～哈哈～

为了好理解，先放上一些Elevate 里关于 Pattern Match 的 Sample Code：

/// <summary> /// Pattern matching is used in functional languages. It can be thought of as a "switch statement on steriods"./// Here's an example of very basic pattern matching using Elevate. /// </summary>[Fact]public void PatternMatchingWithFunctions() {        //given a value        var value = "alpha";         var result = value.Match() //we can start a pattern match like this                 .With(string.IsNullOrEmpty, stringValue => "empty") //causes the pattern match to return "empty" if value is null or empty                 .With(stringValue => value.Contains("a"), stringValue => "contains a!") //match any string containing "a"                 .EndMatch();         Assert.Equal("contains a!", result); } [Fact]public void PatternMatchingWithMatchPatternsAsValues(){        //given a value         var value = "gamma";         //we can equality match against values without having to specify         //a condition function        var result = value.Match()                .With("alpha", stringValue => "1st letter = " + stringValue)                 .With("beta", stringValue => "2nd letter = " + stringValue)                 .With("gamma", stringValue => "3rd letter = " + stringValue)                 .EndMatch();         Assert.Equal("3rd letter = gamma", result); } [Fact]public void PatternMatchingWithMatchPatternsAndResultsAsValues(){        //given a value         var value = "gamma";         //we can also match without having to speficy a lambda for either the         //match predicate or the result        var result = value.Match()                .With("alpha", "first letter")                 .With("beta", "second letter")                .With("gamma", "third letter")                 .EndMatch();         Assert.Equal("third letter", result); } [Fact]public void IncompletePatternMatching(){        //given a value         var stringValue = "alpha, beta";         //if we construct a pattern match that does not match the value         Assert.ThrowsDelegateWithReturn incompleteMatch = () =>                                                         stringValue.Match()                                                        .With(value => value == "alpha", value => "Found foo")                                                         .With(value => value == "beta", value => "Found bar")                                                         .EndMatch();         //evaluating it will throw        Assert.Throws<IncompletePatternMatchException>(incompleteMatch); } [Fact]public void PatternMatchingWithElse(){        //given a value         var stringValue = "alpha, beta";         //we can add Else to cause the incomplete match from above to have a         //default case        var elseMatch =                stringValue.Match()                .With(value => value == "alpha", value => "Found foo")                 .With(value => value == "beta", value => "Found bar")                 .Else(value => "default!")                .EndMatch();         Assert.Equal("default!", elseMatch); } [Fact]public void PatternMatchingElseWithValues(){        //given a value         var stringValue = "alpha, beta";         //we can specify else as a concrete value without having         //to use the input value        var elseMatch =                stringValue.Match()                .With(value => value == "alpha", value => "Found foo")                 .With(value => value == "beta", value => "Found bar")                 .Else("default!")                .EndMatch();         Assert.Equal("default!", elseMatch); }

Elevate原来的代码仅仅支持用一次，没有办法把这个Pattern给持久化住，然后apply给一系列的值～

这是个比较致命的缺陷，于是，我开始研究它的代码～

Elevate中关于Pattern  Match比较关键的几个类是

/// <summary>/// A class containing extensions methods to enable pattern matching. /// </summary>public static class ObjectExtensionsForPatternMatching {    /// <summary>    /// Begins a pattern match on the specified value     /// </summary>    /// <typeparam name="T">The type of the value being matched.</typeparam>     /// <param name="value">The value to match.</param>     /// <returns>The matching context</returns>     public static PatternMatchContext<T> Match<T>(this T value)     {        return new PatternMatchContext<T>(value);     }}

/// <summary>

/// A partially complete pattern match with only the input type specified./// </summary> /// <typeparam name="T">The type returned by this pattern match</typeparam> public class PatternMatchContext<T> {    internal readonly T value;     internal PatternMatchContext(T value)    {        this.value = value;     }     /// <summary>    /// Specifies the first condition to match against. Also defines the type of the result value.     /// </summary>    /// <typeparam name="TResult">The type of the result.</typeparam>     /// <param name="condition">The condition to match against.</param>     /// <param name="result">The result to return if this condition matches.</param>     /// <returns>The pattern match with the selector defined</returns>     public PatternMatch<T, TResult> With<TResult>(         Func<T, bool> condition,        Func<T, TResult> result)     {        if (condition == null)            throw new ArgumentNullException("condition", "condition is null.");         if (result == null)            throw new ArgumentNullException("result", "result is null.");         var match = new PatternMatch<T, TResult>(value);         return match.With(condition, result);    }}

/// <summary> /// A pattern matching block with the return value and the/// the type to match on specified. /// </summary>/// <typeparam name="T">The type of the value being matched.</typeparam> /// <typeparam name="TResult">The type of the result.</typeparam> public class PatternMatch<T, TResult> {    private readonly T value;    private readonly List<Tuple<Func<T, bool>, Func<T, TResult>>> cases          = new List<Tuple<Func<T, bool>, Func<T, TResult>>>();     private Func<T, TResult> elseFunc;     internal PatternMatch(T value)     {        this.value = value;    }     /// <summary>     /// Specifies a condition to match against, and the value to return    /// </summary>     /// <param name="matchCondition">The condition to match with.</param>     /// <param name="matchResult">The result to return if the condition matches.</param>     /// <returns>The current PatternMatch</returns>     public PatternMatch<T, TResult> With(Func<T, bool> matchCondition, Func<T, TResult> matchResult)     {        if (matchCondition == null)            throw new ArgumentNullException("matchCondition", "matchCondition is null.");         if (matchResult == null)            throw new ArgumentNullException("matchResult", "matchResult is null.");         cases.Add(Tuple.Create(matchCondition, matchResult));        return this;     }     /// <summary>    /// Specifies a default result if all conditions fail to match.     /// </summary>    /// <param name="result">The result.</param>     /// <returns>The current PatternMatch</returns>     public PatternMatch<T, TResult> Else(Func<T, TResult> result)     {        if (elseFunc != null)            throw new InvalidOperationException("Cannot have multiple else cases");         elseFunc = result;        return this;    }     /// <summary>     /// Evaluates this pattern match, returning the result of the condition that matches.    /// </summary>     /// <returns>the match resulg</returns>     /// <remarks>If this does not contain a match, this method    /// throws an IncompleteMatchException</remarks>     public TResult EndMatch()    {        if (elseFunc != null)             cases.Add(                Tuple.Create<Func<T, bool>, Func<T, TResult>>(x => true, elseFunc));         foreach (var item in cases)            if (item.First(value))                 return item.Second(value);         throw new IncompleteMatchException("Incomplete pattern match");     }}

由代码可知，Elevate的形成的Function Call Chain中的Context的切换完全是通过返回不同类型的class实现的～在一次一用的环境里，没有问题，但是如果在需要持久化的Case里就会有一些问题～

由于一次一用的实现和持久化的实现的代码几乎没有任何区别～但是Context的切换则会有非常大的不同，如何能够在重用实现的情况下还产生不同的Context（VS的IntelliSence会检测到这种区别，同时在没有强制类型转换的情况下，用户无法调用本不应该调用的Method，例如对一个持久化版的PatternMatch去调用EndMatch()方法，相应的，用户应该调用Apply方法）。

最后我想到了可以利用Interface去标识上下文，而利用同一个class去实现所有的interface，这样，context在切换，但是数据没有复制，调用永远都是一个class。

然而这个时候有存在问题了，由于需要实现ExtensionMethod，为了尽可能的复用代码，我比如让一些方法共集中到一个Interface里，但是同一个方法的调用，返回的Context Interface在一次一用和持久化的场景里，又应该有所不同，于是问题就彻底复杂话了～于是Generic的终极使用方法出现了————Generic的迭代。

public interface IWithContext<T, TResult, TSelf>     where TSelf : IWithContext<T, TResult, TSelf>{    TSelf With(Func<T, bool> condition, Func<T, TResult> result); }

注意 TSelf 的限定～华丽丽的限定！还有With方法的返回类型！哈哈～

这里是完整的代码：

好复杂的继承关系！

public class PatternMatch<T, TResult> :         IInstantMatchContext<T, TResult>,        IWithContext<T, TResult, IInstantMatchContext<T, TResult>>,         IElseContext<T, TResult, IEndMatchContext<TResult>>,         IEndMatchContext<TResult>,        ICompileMatchContext<T, TResult>,         IWithContext<T, TResult, ICompileMatchContext<T, TResult>>,         IElseContext<T, TResult, IAppliableCompilableContext<T, TResult>>,         IAppliableCompilableContext<T, TResult>,        ICompilableContext<T, TResult>,         IApplyContext<T, TResult>{    #region Constructors     internal PatternMatch()    {        HasValue = false;        Cases = new List<MatchCase>();         ElseCase = null;    }     internal PatternMatch(T input)        : this()     {        this.Input = input;        HasValue = true;     }     #endregion     #region Instant Mode Status Fields     private T Input;    private bool HasValue;     #endregion     #region Common Runtime Status Fields     protected List<MatchCase> Cases;     protected Func<T, TResult> ElseCase;     #endregion     #region Functional Methods     protected PatternMatch<T, TResult> With(Func<T, bool> condition, Func<T, TResult> result)     {        if (condition == null)            throw new ArgumentNullException("condition", "condition is null.");         if (result == null)            throw new ArgumentNullException("result", "result is null.");         Cases.Add(new MatchCase(condition, result));        return this;     }     protected PatternMatch<T, TResult> Else(Func<T, TResult> result)     {        if (result == null)            throw new ArgumentNullException("result", "result is null.");         ElseCase = result;         return this;    }     protected TResult EndMatch()     {        if (!HasValue)            throw new InvalidOperationException();         return Apply(Input);    }     protected IApplyContext<T, TResult> Compile()     {        return this;    }     protected TResult Apply(T input)    {        foreach (var foCase in Cases)         {            if (foCase.Condition(input))                return foCase.Result(input);         }         if (ElseCase != null)            return ElseCase(input);         else            throw new IncompletePatternMatchException();     }     #endregion     #region Nested Entity     protected struct MatchCase     {        public MatchCase(Func<T, bool> condition, Func<T, TResult> result)         {            this.Condition = condition;            this.Result = result;         }        public Func<T, bool> Condition;         public Func<T, TResult> Result;    }     #endregion     #region Contextual Methods     #region Instant Mode     #region IWithContext<T,TResult,IInstantMatchContext<T,TResult>> Members     IInstantMatchContext<T, TResult> IWithContext<T, TResult, IInstantMatchContext<T, TResult>>.With(Func<T, bool> condition, Func<T, TResult> result)     {        return this.With(condition, result);    }     #endregion     #region IElseContext<T,TResult,IEndMatchContext<TResult>> Members     IEndMatchContext<TResult> IElseContext<T, TResult, IEndMatchContext<TResult>>.Else(Func<T, TResult> result)     {        return this.Else(result);    }     #endregion     #region IEndMatchContext<TResult> Members     TResult IEndMatchContext<TResult>.EndMatch()     {        return this.EndMatch();    }     #endregion     #endregion     #region Compile Mode     #region IWithContext<T,TResult,ICompileMatchContext<T,TResult>> Members     ICompileMatchContext<T, TResult> IWithContext<T, TResult, ICompileMatchContext<T, TResult>>.With(Func<T, bool> condition, Func<T, TResult> result)     {        return this.With(condition, result);    }     #endregion     #region IElseContext<T,TResult,IAppliableCompilableContext<T,TResult>> Members     IAppliableCompilableContext<T, TResult> IElseContext<T, TResult, IAppliableCompilableContext<T, TResult>>.Else(Func<T, TResult> result)     {        return this.Else(result);    }     #endregion     #region ICompilableContext<T,TResult> Members     IApplyContext<T, TResult> ICompilableContext<T, TResult>.Compile()     {        return this.Compile();    }     #endregion     #region IApplyContext<T,TResult> Members     TResult IApplyContext<T, TResult>.Apply(T input)     {        return this.Apply(input);    }     #endregion     #endregion     #endregion}

public class InitialWithContext<T> : IWithContext<T>

{    private T input;     internal InitialWithContext(T input)     {         this.input = input;    }     #region IWithContext<T> Members     public IInstantMatchContext<T, TResult> With<TResult>(Func<T, bool> condition, Func<T, TResult> result)     {        return (new PatternMatch<T, TResult>(input) as IInstantMatchContext<T, TResult>).With(condition, result);     }     #endregion}

public static class PatternMatch

{    public static <span

Posted via email from 米良的草窝

神一般的一段代码～

收到Elevate(http://elevate.codeplex.com)项目里Pattern Match的启发，对它的实现进行了一些改进，于是写出了这样一段神一般的代码来～

不知道是不是有人能读懂段代码～

代码里把C#的Generic, Extension Method, Lambda Expression, Explicit Implemented Interface等Feature用到了极致～特别是Generic！

太神奇了～哈哈～

为了好理解，先放上一些Elevate 里关于 Pattern Match 的 Sample Code：

/// <summary> /// Pattern matching is used in functional languages. It can be thought of as a "switch statement on steriods"./// Here's an example of very basic pattern matching using Elevate. /// </summary>[Fact]public void PatternMatchingWithFunctions() {        //given a value        var value = "alpha";         var result = value.Match() //we can start a pattern match like this                 .With(string.IsNullOrEmpty, stringValue => "empty") //causes the pattern match to return "empty" if value is null or empty                 .With(stringValue => value.Contains("a"), stringValue => "contains a!") //match any string containing "a"                 .EndMatch();         Assert.Equal("contains a!", result); } [Fact]public void PatternMatchingWithMatchPatternsAsValues(){        //given a value         var value = "gamma";         //we can equality match against values without having to specify         //a condition function        var result = value.Match()                .With("alpha", stringValue => "1st letter = " + stringValue)                 .With("beta", stringValue => "2nd letter = " + stringValue)                 .With("gamma", stringValue => "3rd letter = " + stringValue)                 .EndMatch();         Assert.Equal("3rd letter = gamma", result); } [Fact]public void PatternMatchingWithMatchPatternsAndResultsAsValues(){        //given a value         var value = "gamma";         //we can also match without having to speficy a lambda for either the         //match predicate or the result        var result = value.Match()                .With("alpha", "first letter")                 .With("beta", "second letter")                .With("gamma", "third letter")                 .EndMatch();         Assert.Equal("third letter", result); } [Fact]public void IncompletePatternMatching(){        //given a value         var stringValue = "alpha, beta";         //if we construct a pattern match that does not match the value         Assert.ThrowsDelegateWithReturn incompleteMatch = () =>                                                         stringValue.Match()                                                        .With(value => value == "alpha", value => "Found foo")                                                         .With(value => value == "beta", value => "Found bar")                                                         .EndMatch();         //evaluating it will throw        Assert.Throws<IncompletePatternMatchException>(incompleteMatch); } [Fact]public void PatternMatchingWithElse(){        //given a value         var stringValue = "alpha, beta";         //we can add Else to cause the incomplete match from above to have a         //default case        var elseMatch =                stringValue.Match()                .With(value => value == "alpha", value => "Found foo")                 .With(value => value == "beta", value => "Found bar")                 .Else(value => "default!")                .EndMatch();         Assert.Equal("default!", elseMatch); } [Fact]public void PatternMatchingElseWithValues(){        //given a value         var stringValue = "alpha, beta";         //we can specify else as a concrete value without having         //to use the input value        var elseMatch =                stringValue.Match()                .With(value => value == "alpha", value => "Found foo")                 .With(value => value == "beta", value => "Found bar")                 .Else("default!")                .EndMatch();         Assert.Equal("default!", elseMatch); }

Elevate原来的代码仅仅支持用一次，没有办法把这个Pattern给持久化住，然后apply给一系列的值～

这是个比较致命的缺陷，于是，我开始研究它的代码～

Elevate中关于Pattern  Match比较关键的几个类是

/// <summary>/// A class containing extensions methods to enable pattern matching. /// </summary>public static class ObjectExtensionsForPatternMatching {    /// <summary>    /// Begins a pattern match on the specified value     /// </summary>    /// <typeparam name="T">The type of the value being matched.</typeparam>     /// <param name="value">The value to match.</param>     /// <returns>The matching context</returns>     public static PatternMatchContext<T> Match<T>(this T value)     {        return new PatternMatchContext<T>(value);     }}

/// <summary>

/// A partially complete pattern match with only the input type specified./// </summary> /// <typeparam name="T">The type returned by this pattern match</typeparam> public class PatternMatchContext<T> {    internal readonly T value;     internal PatternMatchContext(T value)    {        this.value = value;     }     /// <summary>    /// Specifies the first condition to match against. Also defines the type of the result value.     /// </summary>    /// <typeparam name="TResult">The type of the result.</typeparam>     /// <param name="condition">The condition to match against.</param>     /// <param name="result">The result to return if this condition matches.</param>     /// <returns>The pattern match with the selector defined</returns>     public PatternMatch<T, TResult> With<TResult>(         Func<T, bool> condition,        Func<T, TResult> result)     {        if (condition == null)            throw new ArgumentNullException("condition", "condition is null.");         if (result == null)            throw new ArgumentNullException("result", "result is null.");         var match = new PatternMatch<T, TResult>(value);         return match.With(condition, result);    }}

/// <summary> /// A pattern matching block with the return value and the/// the type to match on specified. /// </summary>/// <typeparam name="T">The type of the value being matched.</typeparam> /// <typeparam name="TResult">The type of the result.</typeparam> public class PatternMatch<T, TResult> {    private readonly T value;    private readonly List<Tuple<Func<T, bool>, Func<T, TResult>>> cases          = new List<Tuple<Func<T, bool>, Func<T, TResult>>>();     private Func<T, TResult> elseFunc;     internal PatternMatch(T value)     {        this.value = value;    }     /// <summary>     /// Specifies a condition to match against, and the value to return    /// </summary>     /// <param name="matchCondition">The condition to match with.</param>     /// <param name="matchResult">The result to return if the condition matches.</param>     /// <returns>The current PatternMatch</returns>     public PatternMatch<T, TResult> With(Func<T, bool> matchCondition, Func<T, TResult> matchResult)     {        if (matchCondition == null)            throw new ArgumentNullException("matchCondition", "matchCondition is null.");         if (matchResult == null)            throw new ArgumentNullException("matchResult", "matchResult is null.");         cases.Add(Tuple.Create(matchCondition, matchResult));        return this;     }     /// <summary>    /// Specifies a default result if all conditions fail to match.     /// </summary>    /// <param name="result">The result.</param>     /// <returns>The current PatternMatch</returns>     public PatternMatch<T, TResult> Else(Func<T, TResult> result)     {        if (elseFunc != null)            throw new InvalidOperationException("Cannot have multiple else cases");         elseFunc = result;        return this;    }     /// <summary>     /// Evaluates this pattern match, returning the result of the condition that matches.    /// </summary>     /// <returns>the match resulg</returns>     /// <remarks>If this does not contain a match, this method    /// throws an IncompleteMatchException</remarks>     public TResult EndMatch()    {        if (elseFunc != null)             cases.Add(                Tuple.Create<Func<T, bool>, Func<T, TResult>>(x => true, elseFunc));         foreach (var item in cases)            if (item.First(value))                 return item.Second(value);         throw new IncompleteMatchException("Incomplete pattern match");     }}

由代码可知，Elevate的形成的Function Call Chain中的Context的切换完全是通过返回不同类型的class实现的～在一次一用的环境里，没有问题，但是如果在需要持久化的Case里就会有一些问题～

由于一次一用的实现和持久化的实现的代码几乎没有任何区别～但是Context的切换则会有非常大的不同，如何能够在重用实现的情况下还产生不同的Context（VS的IntelliSence会检测到这种区别，同时在没有强制类型转换的情况下，用户无法调用本不应该调用的Method，例如对一个持久化版的PatternMatch去调用EndMatch()方法，相应的，用户应该调用Apply方法）。

最后我想到了可以利用Interface去标识上下文，而利用同一个class去实现所有的interface，这样，context在切换，但是数据没有复制，调用永远都是一个class。

然而这个时候有存在问题了，由于需要实现ExtensionMethod，为了尽可能的复用代码，我比如让一些方法共集中到一个Interface里，但是同一个方法的调用，返回的Context Interface在一次一用和持久化的场景里，又应该有所不同，于是问题就彻底复杂话了～于是Generic的终极使用方法出现了————Generic的迭代。

public interface IWithContext<T, TResult, TSelf>     where TSelf : IWithContext<T, TResult, TSelf>{    TSelf With(Func<T, bool> condition, Func<T, TResult> result); }

注意 TSelf 的限定～华丽丽的限定！还有With方法的返回类型！哈哈～

这里是完整的代码：

好复杂的继承关系！

public class PatternMatch<T, TResult> :         IInstantMatchContext<T, TResult>,        IWithContext<T, TResult, IInstantMatchContext<T, TResult>>,         IElseContext<T, TResult, IEndMatchContext<TResult>>,         IEndMatchContext<TResult>,        ICompileMatchContext<T, TResult>,         IWithContext<T, TResult, ICompileMatchContext<T, TResult>>,         IElseContext<T, TResult, IAppliableCompilableContext<T, TResult>>,         IAppliableCompilableContext<T, TResult>,        ICompilableContext<T, TResult>,         IApplyContext<T, TResult>{    #region Constructors     internal PatternMatch()    {        HasValue = false;        Cases = new List<MatchCase>();         ElseCase = null;    }     internal PatternMatch(T input)        : this()     {        this.Input = input;        HasValue = true;     }     #endregion     #region Instant Mode Status Fields     private T Input;    private bool HasValue;     #endregion     #region Common Runtime Status Fields     protected List<MatchCase> Cases;     protected Func<T, TResult> ElseCase;     #endregion     #region Functional Methods     protected PatternMatch<T, TResult> With(Func<T, bool> condition, Func<T, TResult> result)     {        if (condition == null)            throw new ArgumentNullException("condition", "condition is null.");         if (result == null)            throw new ArgumentNullException("result", "result is null.");         Cases.Add(new MatchCase(condition, result));        return this;     }     protected PatternMatch<T, TResult> Else(Func<T, TResult> result)     {        if (result == null)            throw new ArgumentNullException("result", "result is null.");         ElseCase = result;         return this;    }     protected TResult EndMatch()     {        if (!HasValue)            throw new InvalidOperationException();         return Apply(Input);    }     protected IApplyContext<T, TResult> Compile()     {        return this;    }     protected TResult Apply(T input)    {        foreach (var foCase in Cases)         {            if (foCase.Condition(input))                return foCase.Result(input);         }         if (ElseCase != null)            return ElseCase(input);         else            throw new IncompletePatternMatchException();     }     #endregion     #region Nested Entity     protected struct MatchCase     {        public MatchCase(Func<T, bool> condition, Func<T, TResult> result)         {            this.Condition = condition;            this.Result = result;         }        public Func<T, bool> Condition;         public Func<T, TResult> Result;    }     #endregion     #region Contextual Methods     #region Instant Mode     #region IWithContext<T,TResult,IInstantMatchContext<T,TResult>> Members     IInstantMatchContext<T, TResult> IWithContext<T, TResult, IInstantMatchContext<T, TResult>>.With(Func<T, bool> condition, Func<T, TResult> result)     {        return this.With(condition, result);    }     #endregion     #region IElseContext<T,TResult,IEndMatchContext<TResult>> Members     IEndMatchContext<TResult> IElseContext<T, TResult, IEndMatchContext<TResult>>.Else(Func<T, TResult> result)     {        return this.Else(result);    }     #endregion     #region IEndMatchContext<TResult> Members     TResult IEndMatchContext<TResult>.EndMatch()     {        return this.EndMatch();    }     #endregion     #endregion     #region Compile Mode     #region IWithContext<T,TResult,ICompileMatchContext<T,TResult>> Members     ICompileMatchContext<T, TResult> IWithContext<T, TResult, ICompileMatchContext<T, TResult>>.With(Func<T, bool> condition, Func<T, TResult> result)     {        return this.With(condition, result);    }     #endregion     #region IElseContext<T,TResult,IAppliableCompilableContext<T,TResult>> Members     IAppliableCompilableContext<T, TResult> IElseContext<T, TResult, IAppliableCompilableContext<T, TResult>>.Else(Func<T, TResult> result)     {        return this.Else(result);    }     #endregion     #region ICompilableContext<T,TResult> Members     IApplyContext<T, TResult> ICompilableContext<T, TResult>.Compile()     {        return this.Compile();    }     #endregion     #region IApplyContext<T,TResult> Members     TResult IApplyContext<T, TResult>.Apply(T input)     {        return this.Apply(input);    }     #endregion     #endregion     #endregion}

public class InitialWithContext<T> : IWithContext<T>

{    private T input;     internal InitialWithContext(T input)     {         this.input = input;    }     #region IWithContext<T> Members     public IInstantMatchContext<T, TResult> With<TResult>(Func<T, bool> condition, Func<T, TResult> result)     {        return (new PatternMatch<T, TResult>(input) as IInstantMatchContext<T, TResult>).With(condition, result);     }     #endregion}

public static class PatternMatch

{    public static <span

Posted via email from 米良的实验室

中文的Culture名字什么时候升级了？？？zh-CHS似乎被zh-HANS代替了～

http://msdn.microsoft.com/en-us/library/dd997383.aspx#new_specific_cultures

The display names of Chinese cultures have changed to follow the naming convention LanguageName ([Script,] Country/RegionName). In the .NET Framework 4, the word "Legacy" has been appended to the zh-CHS and zh-CHT display names to differentiate them from zh-Hans and zh-Hant. zh, which was recently introduced into Windows, has “Chinese” as its display name.

Display name	Culture name	LCID
Chinese	zh	0x7804
Chinese (Simplified) Legacy	zh-CHS	0x0004
Chinese (Traditional) Legacy	zh-CHT	0x7C04
Chinese (Simplified)	zh-Hans	0x0004
Chinese (Traditional)	zh-Hant	0x7C04
Chinese (Simplified, PRC)	zh-CN	0x0804
Chinese (Traditional, Hong Kong S.A.R.)	zh-HK	0x0C04
Chinese (Traditional, Macao S.A.R.)	zh-MO	0x1404
Chinese (Simplified, Singapore)	zh-SG	0x1004
Chinese (Traditional, Taiwan)	zh-TW	0x0404

The parent chain of the Chinese cultures now includes the root Chinese culture. The following examples show the complete parent chain for two of the Chinese specific cultures:

• zh-CN → zh-CHS → zh-Hans → zh → Invariant

• zh-TW → zh-CHT → zh-Hant → zh → Invariant

Tibetan (PRC), French (Monaco), Tamazight (Latin, Algeria), and Spanish (Spain, International Sort) display names were updated as well. When the display name changes, usually the English and native names reflect this change; however, the ISO and abbreviated names of the script, language, and country may change as well.

从描述上看，似乎是国际上开始注意到并开始区分中文中除了普通话外的各个变种，比如粤语、闽南语、吴语、台语等，所以zh-CHS并不能准确的表达含义，因此改为了zh-Hans

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的草窝

中文的Culture名字什么时候升级了？？？zh-CHS似乎被zh-HANS代替了～

http://msdn.microsoft.com/en-us/library/dd997383.aspx#new_specific_cultures

The display names of Chinese cultures have changed to follow the naming convention LanguageName ([Script,] Country/RegionName). In the .NET Framework 4, the word "Legacy" has been appended to the zh-CHS and zh-CHT display names to differentiate them from zh-Hans and zh-Hant. zh, which was recently introduced into Windows, has “Chinese” as its display name.

Display name	Culture name	LCID
Chinese	zh	0x7804
Chinese (Simplified) Legacy	zh-CHS	0x0004
Chinese (Traditional) Legacy	zh-CHT	0x7C04
Chinese (Simplified)	zh-Hans	0x0004
Chinese (Traditional)	zh-Hant	0x7C04
Chinese (Simplified, PRC)	zh-CN	0x0804
Chinese (Traditional, Hong Kong S.A.R.)	zh-HK	0x0C04
Chinese (Traditional, Macao S.A.R.)	zh-MO	0x1404
Chinese (Simplified, Singapore)	zh-SG	0x1004
Chinese (Traditional, Taiwan)	zh-TW	0x0404

The parent chain of the Chinese cultures now includes the root Chinese culture. The following examples show the complete parent chain for two of the Chinese specific cultures:

• zh-CN → zh-CHS → zh-Hans → zh → Invariant

• zh-TW → zh-CHT → zh-Hant → zh → Invariant

Tibetan (PRC), French (Monaco), Tamazight (Latin, Algeria), and Spanish (Spain, International Sort) display names were updated as well. When the display name changes, usually the English and native names reflect this change; however, the ISO and abbreviated names of the script, language, and country may change as well.

从描述上看，似乎是国际上开始注意到并开始区分中文中除了普通话外的各个变种，比如粤语、闽南语、吴语、台语等，所以zh-CHS并不能准确的表达含义，因此改为了zh-Hans

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的实验室

今天太刺激了，硬盘挂掉一块～代码的Working Copy和SVN的Responsitory一起丢掉了～

最近机子各种莫名其妙的死机，今天终于发现原因了～原来是一块SATA的盘的数据接口塑料断掉了～然后接触不良～于是导致Kernel Panic～然后直接断电保护～

今天系统系统没有死机，VS直接挂掉～然后Task Manager和Process Explorer启动不能～～

无奈只好重启～BIOS报告SATA设备丢失～拆开机箱一看～SATA盘的数据接口只剩下几根弯掉的铜片～塑料支架已经彻底断掉，并且随SATA线一起脱落了～

把坏盘断电～重启，系统启动正常～于是高兴了～看样子没啥大问题～

系统启动后一看～傻眼了～

除了系统卷和一个备份用的动态卷～其他所有卷都丢失了～其中包括工作盘和服务器的数据盘～

工作盘里有所有的代码的Working Copy和各种引用资源等～还有项目文档，界面的设计稿，效果图等等～

服务器的数据盘则是SVN和FTP，IIS，Apache，Tomcat等的站点数据～全部都丢失了～

差点抓狂！

还好～后来小心翼翼的把那块接口死掉的硬盘接回机箱，把数据导了出来～

不过这次的经历，让我决定把SVN搬离我自己的工作机～我打算用我的iMac来做服务器～

研究了一下XCode内置了一个SVN服务器svnserve～没有搞太明白了～

不知道有没有办法把原来Windows版的VisualSVN的Responsitory迁移到Mac里～

svnserve的官方文档：http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man8/svnserve.8.html

这玩意儿似乎是Darwin的一部分～

或者有没有Mac下比较推荐的SVN Server

从Apache的官方文档来看：Mac下有4个官方推荐的Package：Fink，MacPort，openCollabNet和svnserve～

svnserve玩不明白～我打算搞个Fink来看看～

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的草窝

Change the hostname in Mac OS X [osx]

by Larry on May 23, 2008

in Mac,howto,programming

When I log into the network at my job my Mac’s hostname always turns to:

larryx.na.corp.ipgnetwork.com

I have my local hostname set to:

larryx.local

So What I would like to do is set my Mac’s hostname to my local hostname. You can do this all from Terminal in a single line.

Run this command in Terminal:

sudo scutil --set HostName larryx.local

This is also helpful if you’re in Terminal and have a really long hostname at your prompt. If you want to view your current hostname, run this command in Terminal:

hostname

This is what it looked like for me:

Last login: Fri May 23 09:55:20 on ttys000 larryx:~ lgordon$ hostname larryx.na.corp.ipgnetwork.com larryx:~ lgordon$ sudo scutil --set HostName larryx.local Password: larryx:~ lgordon$ hostname larryx.local

Care of: CodeSnippets

via blog.psyrendust.com

终于把我的iMac的名字改过来了～但是似乎还是ping不通～可能需要一点时间刷新纪录～

Posted via email from 米良的草窝

Visual Studio T4 中定位当前Solution的技巧

Visual Studio 中的T4模板可以极其方便的利用代码生成代码、配置或者任何需要生成的内容。

其实T4从VS08开始似乎就内置了支持，在VS05下似乎也可以用插件的方式添加支持。而在VS10下，还有了专门的T4的Editor的Extension。

然而虽然支持的增强，但是T4似乎被MSFT认定为DSL的技术，似乎有些小众，所以并没有被广泛的推广，资料也特别的少和难找。MSDN上的内容基本都和DSL有关，远远超出了做基本代码生成模板的需求。

按照我摸索的经验，把T4模板作为代码IDE内置的轻量级的代码生成工具使用是，存在一个致命的缺陷，就是模板和其容器缺乏一个很方便的数据输入的通用通道，因此Template内无法获取到当前文件的路径等基本信息，这对资源的引用带来了一定程度的麻烦。

一般来说为了模板的泛用性，一半都会把HostSpecific设置为False，这时，TextTransform对象是没有Host属性的，因此没有办法获知当前Solution或者Project的文件路径信息，同时也就无法获取到同一个Solution或者Project下的其他相关文件。

然而即使把HostSpecific设置为True，也存在巨大的问题，因为一般来说代码的Build环境和Development环境是不一样的，Build Team很少会利用Visual Studio去编译代码。

因此MSDN教授的利用VS API的方法的泛用新非常差：

MSDN有如下一段代码：http://msdn.microsoft.com/en-us/library/dd820614.aspx

<#@ template debug="false" hostspecific="true" language="C#" #> ... <#@ assembly name="EnvDTE" #> ... EnvDTE.DTE dte = (EnvDTE.DTE) ((IServiceProvider) this.Host) .GetService(typeof(EnvDTE.DTE)); // Open the prototype document. XmlDocument doc = new XmlDocument(); doc.Load(System.IO.Path.Combine(dte.ActiveDocument.Path, "exampleXml.xml"));

这段代码利用EnvDTE去获取当前的文件路径，其实适用性非常差。

经过研究，我发现了一个更加方便和靠谱的方式：

可以利用反射和Assembly Reference机制去定位Solution的文件位置。

首先在自己的Solution中加入一个.net的Assembly，可以为DLL或者Exe，我们把这个文件叫做Location Reference Assembly(LRA)

然后在T4模板中利用引用该Assembly。由于assembly 的引用指令支持 VS 环境变量 ，因此我们可以利用$(SolutionDir)的值和相对路径去定位LRA。

然后在T4模板的代码中利用反射获取LRA的Assembly对象，然后从Assembly.Location属性就是LRA的绝对地址。

这时在利用Path.Combine就可以获取到$(SolutionDir)的值。

随后就能取到任何Project Item的Path了～

实例代码如下：SolutionVersionConvertUtilility.exe是我Solution里的一个用于进行VS10和VS08的Solution文件互转的工具，这里被我当作了LRA使用

<#@ assembly Name="$(SolutionDir)Debug Scripts\SolutionVersionConvertUtilility.exe" #> 

<#

public string SolutionPath{ get { return Path.Combine(System.Reflection.Assembly.GetAssembly(typeof(Windy.Utilities.SolutionVersionConversion.SolutionVersionConverter)).Location,".."); } }

#>

SolutionPath就可以很好的获取到Solution的文件夹路径！

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的实验室

Visual Studio T4 中定位当前Solution的技巧

Visual Studio 中的T4模板可以极其方便的利用代码生成代码、配置或者任何需要生成的内容。

其实T4从VS08开始似乎就内置了支持，在VS05下似乎也可以用插件的方式添加支持。而在VS10下，还有了专门的T4的Editor的Extension。

然而虽然支持的增强，但是T4似乎被MSFT认定为DSL的技术，似乎有些小众，所以并没有被广泛的推广，资料也特别的少和难找。MSDN上的内容基本都和DSL有关，远远超出了做基本代码生成模板的需求。

按照我摸索的经验，把T4模板作为代码IDE内置的轻量级的代码生成工具使用是，存在一个致命的缺陷，就是模板和其容器缺乏一个很方便的数据输入的通用通道，因此Template内无法获取到当前文件的路径等基本信息，这对资源的引用带来了一定程度的麻烦。

一般来说为了模板的泛用性，一半都会把HostSpecific设置为False，这时，TextTransform对象是没有Host属性的，因此没有办法获知当前Solution或者Project的文件路径信息，同时也就无法获取到同一个Solution或者Project下的其他相关文件。

然而即使把HostSpecific设置为True，也存在巨大的问题，因为一般来说代码的Build环境和Development环境是不一样的，Build Team很少会利用Visual Studio去编译代码。

因此MSDN教授的利用VS API的方法的泛用新非常差：

MSDN有如下一段代码：http://msdn.microsoft.com/en-us/library/dd820614.aspx

<#@ template debug="false" hostspecific="true" language="C#" #> ... <#@ assembly name="EnvDTE" #> ... EnvDTE.DTE dte = (EnvDTE.DTE) ((IServiceProvider) this.Host) .GetService(typeof(EnvDTE.DTE)); // Open the prototype document. XmlDocument doc = new XmlDocument(); doc.Load(System.IO.Path.Combine(dte.ActiveDocument.Path, "exampleXml.xml"));

这段代码利用EnvDTE去获取当前的文件路径，其实适用性非常差。

经过研究，我发现了一个更加方便和靠谱的方式：

可以利用反射和Assembly Reference机制去定位Solution的文件位置。

首先在自己的Solution中加入一个.net的Assembly，可以为DLL或者Exe，我们把这个文件叫做Location Reference Assembly(LRA)

然后在T4模板中利用引用该Assembly。由于assembly 的引用指令支持 VS 环境变量 ，因此我们可以利用$(SolutionDir)的值和相对路径去定位LRA。

然后在T4模板的代码中利用反射获取LRA的Assembly对象，然后从Assembly.Location属性就是LRA的绝对地址。

这时在利用Path.Combine就可以获取到$(SolutionDir)的值。

随后就能取到任何Project Item的Path了～

实例代码如下：SolutionVersionConvertUtilility.exe是我Solution里的一个用于进行VS10和VS08的Solution文件互转的工具，这里被我当作了LRA使用

<#@ assembly Name="$(SolutionDir)Debug Scripts\SolutionVersionConvertUtilility.exe" #> 

<#

public string SolutionPath{ get { return Path.Combine(System.Reflection.Assembly.GetAssembly(typeof(Windy.Utilities.SolutionVersionConversion.SolutionVersionConverter)).Location,".."); } }

#>

SolutionPath就可以很好的获取到Solution的文件夹路径！

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的草窝

我被这种代码搞崩溃了

我崩溃了～参考了一下一个做底层的同事写的代码，里面的代码，完全就是那C#当C++写～

例如有这样一行：

prop.Value.GetType().ToString().Equals("System.Byte[]")

我很无语～

一句 “prop.Value is byte[]” 就解决的问题被他倒腾了N次搞成了现在这个样子～

我很无语！非常的无语！

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的草窝

CA Technology ARCserve RHA Team 招聘

 又有招聘了

Software Engineer /Senior Software Engineer  (C++)

1

Job Overview

This position is responsible for developing software applications for CA ARCserve product line. CA ARCserve provides industry leading data protection and high availability solutions. See detail from http://www.arcserve.com

This position is based on CA’s China Technology Center (CTC) in Beijing. Join CTC, you work in a team consist of hundreds of talented engineers, also a team that uses world class development process and tools to create the best in class software of the industry.     

Key Responsibilities

·         Research critical enterprise applications and advanced enterprise software architecture

·         Design high availability solutions for enterprise applications

·         Design and code, often for the complex units/modules/products that meet functional and business requirements.

·         Perform unit/module testing of software to find and correct errors.

·         Contribute innovative ideas and thoughts

Skills and experience

1.      Strong programming experience on C++ technologies.

2.       Good knowledge and programming experience on C#/.NET (Good Plus).

3.       Strong knowledge and troubleshooting skill on Windows platform(OS, Domain, Security, Network, …).

4.     Good knowledge on complex enterprise application and infrastructure, like Exchange, SharePoint, MSSQL, IIS, Dynamics, MSCS… (Good Plus).

5.     Good skills on software framework design and development.

6.       Excellent written and verbal communication skills in English.

7.       Has passion for solving complex problems. Working smart and good learning ability.

Preferred Education

No specific requirement

Work Experience

No specific requirement

有意者请把简历发送到Di.Wen at ca.com

TimNew
------------
Release your passion
To Realize your potential

Posted via email from 米良的草窝