Dziś założyłem sobie konto na Box.Net. Po ostatnich różnych wybojach z Dropboxem postanowiłem zmienić usługę właśnie na Boxa. Dodatkowo Box.Net daje 5GB miejsca na darmowym koncie.

Po zalogowaniu okazało się, że klient do synchronizacji danych pomiędzy komputerem a usługą jest dostępny tylko dla kont płatnych (bussiness). Na szczęście da się to sprytnie obejść korzystając z możłiwości mapowania dysków sieciowych w Windows. :)

Po pierwsze należy pobrać i zainstalować Software Update for Web Folders. Później pozostaje już tylko (prawie) standardowe mapowanie dysku sieciowego. Przy czym zamiast mapować dysk w sieci lokalnej należy wybrać opcję mapowania dysku w internecie, gdzie wpisujemy adres https://www.box.net/dav.

Po zaakceptowaniu logujemy się na swoje konto pamiętając, aby zaznaczyć opcję zapamiętania użytkownika i hasła.

Co z samą synchronizacją? Teraz możemy posłużyć się zwykłym Task Schedulerem. Tworzymy task, który w pewnych odstępach czasu będzie pchał wybrane dane "w chmurę".

Opis mapowania dysku znalazłem na Techie-Buzz.com. Wpis z 2006 roku. Aż dziw bieże, że do tej pory nie ma darmowego i ogólnie znanego klienta do synchronizacji dla tej usługi (albo ja przynajmniej jeszcze nie znalazłem). Na dodatek na samej stronie Box.Net można przeczytać, że klient na MAC'a będzie "niebawem". Wow... :)

Mimo wszystko kopiowanie na i z działa sprawnie i szybko (jak na moje łącze).

Komunikat z tytułu dostałem na przywitanie dziś rano od mojego Outlook'a. Żadnego wyjaśnienia więcej. Na szczęście wujek Google pomógł mi bardzo szybko podpowiadając celną uwagę na witrynie social.answers.microsoft.com. W moim przypadku pomogło uruchomienie Outlook'a z dodatkowym parametrem: Start -> Run... -> "Outlook.exe /resetnavpane" Dzień zaczął się paskudnie, ale na szczęście obyło się bez reinstalacji. :)

Łukasz Kurzyniec wspomniał o bardzo fajnym sposobie formatowania stringa, gdzie zamiast kolejnych indeksów {0}, {1}, itd podaje się nazwy właściwości, a jako źródło obiekt je posiadający. Niestety nie mogłem dodać komentarza na blogu Łukasza, stąd ten post. Swego czasu Phill Haack zainteresował się tym tematem i pokazał inne implementacje. Obecnie dzięki Niemu używam implementacji Henri'ego, która to mimo większej ilości kodu okazała się najszybsza.

Dodatkowo w swojej implementacji dodałem jedno przeciążenie, dzięki któremu możemy określi czy brak właściwości odpowiadającej znalezionemu parametrowi ma wyrzucić wyjątek czy też nie. Przydatne przy bardziej zaawansowanym formatowaniu/parsowaniu.

Poniżej przeklejam kod, aby nigdzie się nie zgubił ;) Acha, u mnie ta metoda nazywa się FormatNamed.

public static string FormatNamed(this string format, object source)
{
    return FormatNamed(format, source, false);
}
public static string FormatNamed(this string format, object source, bool ignoreNotFound)
{
    if (format == null)
    {
        throw new ArgumentNullException("format");
    }
    StringBuilder result = new StringBuilder(format.Length * 2);
    using (var reader = new StringReader(format))
    {
        StringBuilder expression = new StringBuilder();
        int @char = -1;
        State state = State.OutsideExpression;
        
        do
        {
            switch (state)
            {
                case State.OutsideExpression:
                    @char = reader.Read();
                    switch (@char)
                    {
                        case -1:
                            state = State.End;
                            break;
                        case '{':
                            state = State.OnOpenBracket;
                            break;
                        case '}':
                            state = State.OnCloseBracket;
                            break;
                        default:
                            result.Append((char)@char);
                            break;
                    }
                    break;
                case State.OnOpenBracket:
                    @char = reader.Read();
                    switch (@char)
                    {
                        case -1:
                            throw new FormatException();
                        case '{':
                            result.Append('{');
                            state = State.OutsideExpression;
                            break;
                        default:
                            expression.Append((char)@char);
                            state = State.InsideExpression;
                            break;
                    }
                    break;
                case State.InsideExpression:
                    @char = reader.Read();
                    switch (@char)
                    {
                        case -1:
                            throw new FormatException();
                        case '}':
                            result.Append(OutExpression(source, expression.ToString(), ignoreNotFound));
                            expression.Length = 0;
                            state = State.OutsideExpression;
                            break;
                        default:
                            expression.Append((char)@char);
                            break;
                    }
                    break;
                case State.OnCloseBracket:
                    @char = reader.Read();
                    switch (@char)
                    {
                        case '}':
                            result.Append('}');
                            state = State.OutsideExpression;
                            break;
                        default:
                            throw new FormatException();
                    }
                    break;
                default:
                    throw new InvalidOperationException("Invalid state.");
            }
        } while (state != State.End);
    }
 
    return result.ToString();
}
 
private static string OutExpression(object source, string expression, bool ignoreNotFound)
{
    string format = "";
    string orygexpression = expression;
 
    int colonIndex = expression.IndexOf(':');
    if (colonIndex > 0)
    {
        format = expression.Substring(colonIndex + 1);
        expression = expression.Substring(0, colonIndex);
    }
 
    try
    {
        if (String.IsNullOrEmpty(format))
        {
            return (DataBinder.Eval(source, expression) ?? "").ToString();
        }
        return DataBinder.Eval(source, expression, "{0:" + format + "}") ?? "";
    }
    catch (HttpException)
    {
        if (!ignoreNotFound)
        {
            throw new FormatException();
        }
        else
        {
            return orygexpression;
        }
    }
}
 
private enum State
{
    OutsideExpression,
    OnOpenBracket,
    InsideExpression,
    OnCloseBracket,
    End
}

Taka mała ciekawostka. Jak włączyć widoczność białych znaków w Visual Studio 2008? Wystarczy kombinacja klawiszy:

Ctrl + E + S

Kombinacja działa naprzemiennie, tzn. wciskając ją ponownie oznaczenie białych znaków zniknie. U mnie widać je tak:

Niestety nie jestem w stanie sprawdzić czy ten skrót działa w VS 2005, ale domniemam, że tak. :)

Zmodernizowałem sobie ostatnio środowisko pracy i wgrałem spreparowaną wersję ustawień, którą przygotował Rob Conery Zmodyfikowałem nieco kolor string'a oraz użyłem czcionkę Consolas o wielkości 11px. Większa czcionka z jednej strony powoduje, że niby mniej widać na ekranie, ale z drugiej strony piszę mniejsze kawałki kodu (krótsze linie), bardziej czytelne. :)  

Moje Dark Theme do pobrania. Plik zawiera osobne ustawienia do Visual Web Developer 2008 oraz do Visual C# 2008. A Wy jakie macie ustawienia? :)