public static void Execute()
        {
            // horrible hack

            Clear clear = new Clear();
            Create create = new Create();
            Delete delete = new Delete();
            Exit exit = new Exit();
            Ping ping = new Ping();
            SList slist = new SList();
            Start start = new Start();
            Help help = new Help();
            Alias alias = new Alias();
            View view = new View();

            // im sorry mom
            HelpDisplay.Add("   " + clear.Name + " - " + clear.Description);
            HelpDisplay.Add("   " + create.Name + " - " + create.Description);
            HelpDisplay.Add("   " + delete.Name + " - " + delete.Description);
            HelpDisplay.Add("   " + exit.Name + " - " + exit.Description);
            HelpDisplay.Add("   " + ping.Name + " - " + ping.Description);
            HelpDisplay.Add("   " + slist.Name + " - " + slist.Description);
            HelpDisplay.Add("   " + start.Name + " - " + start.Description);
            HelpDisplay.Add("   " + alias.Name + " - " + alias.Description);
            HelpDisplay.Add("   " + help.Name + " - " + help.Description);
            HelpDisplay.Add("   " + view.Name + " - " + view.Description);

            foreach (string command in HelpDisplay)
                Console.WriteLine(command);

            HelpDisplay.Clear(); // static list.
        }

 public AggregateSubqueryExpression(Alias groupByAlias, Expression aggregateInGroupSelect, ScalarExpression aggregateAsSubquery)
     : base(MongoExpressionType.AggregateSubquery, aggregateAsSubquery.Type)
 {
     GroupByAlias = groupByAlias;
     AggregateInGroupSelect = aggregateInGroupSelect;
     AggregateAsSubquery = aggregateAsSubquery;
 }

 protected override Expression VisitSelect(SelectExpression select)
 {
     var newAlias = new Alias();
     _map[select.Alias] = newAlias;
     select = (SelectExpression)base.VisitSelect(select);
     return new SelectExpression(newAlias, select.Fields, select.From, select.Where, select.OrderBy, select.GroupBy, select.IsDistinct, select.Skip, select.Take);
 }

 public FieldExpression(Expression expression, Alias alias, string name)
     : base(MongoExpressionType.Field, expression.Type)
 {
     Alias = alias;
     Expression = expression;
     Name = name;
 }

        internal ReadOnlyCollection<MixinEntityExpression> GenerateMixins(Alias tableAlias, QueryBinder binder, Expression id)
        {
            if (this.Mixins == null)
                return null;

            return this.Mixins.Values.Select(m => (MixinEntityExpression)m.GetExpression(tableAlias, binder, id)).ToReadOnly();
        }

 public FieldExpression(Expression expression, Alias alias, string name, BsonMemberMap memberMap)
     : base(MongoExpressionType.Field, expression.Type)
 {
     Alias = alias;
     Expression = expression;
     Name = name;
     MemberMap = memberMap;
 }

        int _idCounter; //id作成のための順次番号生成カウンタ

        #endregion Fields

        #region Constructors

        public MailSave(MailBox mailBox, Alias alias,MailQueue mailQueue, Logger logger, ReceivedHeader receivedHeader, List<string> domainList)
        {
            _mailBox = mailBox;
            _alias = alias;
            _mailQueue = mailQueue;
            _logger = logger;
            _receivedHeader = receivedHeader;
            _domainList = domainList;
            _localBox = new LocalBox(_logger);
        }

 protected virtual bool CompareAlias(Alias a, Alias b)        
 {
     if (_aliasScope != null)
     {
         Alias mapped;
         if (_aliasScope.TryGetValue(a, out mapped))
             return mapped == b;
     }
     return a == b;
 }

 public Warn()
 {
     #if JTVBOT
     Privilege = PrivilegeLevel.Voiced;
     #else
     Privilege = PrivilegeLevel.None;
     #endif
     Alias alias = new Alias(this, "+w");
     alias.RequiresPrefix = false;
     alias.ForbidsPrefix = true;
 }

		public void NoLeadingUnderscores()
		{
			Alias alias = new Alias( "suffix" );
			Dialect.Dialect dialect = new Dialect.MsSql2000Dialect();
			
			Assert.IsFalse( 
				alias.ToAliasString( "__someIdentifier", dialect )
				.StartsWith( "_" ) );

			Assert.IsFalse( 
				alias.ToUnquotedAliasString( "__someIdentifier", dialect )
				.StartsWith( "_" ) );
		}

        internal Expression GetIdExpression(Alias alias)
        {
            var field = Fields.TryGetC(Table.fiId.Name);

            if (field == null)
            {
                field = Fields.Values.FirstOrDefault(f => f .Field is IColumn && ((IColumn)f.Field).PrimaryKey);
                if (field == null)
                    return null;
            }

            return field.Field.GetExpression(alias, null, null);
        }

        public void IsUserによる登録ユーザの確認(String user, bool expected)
        {
            //setUp
            var sut = new Alias( _domainList, _mailBox);
            sut.Add("dmy","user1,user2",new Logger());
            sut.Add("user1", "user3,user4", new Logger());

            var rcptList = new List<MailAddress>();
            rcptList.Add(new MailAddress("[email protected]"));

            //exercise
            var actual = sut.IsUser(user);
            //verify
            Assert.That(actual, Is.EqualTo(expected));
        }

    public void Foo(bool b)
    {
      Alias tmp = new Alias();

      tmp.x = -11;

      Alias alias = tmp;

      if(b)
      {
        alias.x = 10;
      }

      Contract.Assert(tmp.x == -11);
    }

        static internal ProjectedColumns ProjectColumns(Expression projector, Alias newAlias, bool isGroupKey = false, bool selectTrivialColumns = false)
        {
            Expression newProj;
            var candidates = DbExpressionNominator.Nominate(projector, out newProj, isGroupKey: isGroupKey);

            ColumnProjector cp = new ColumnProjector
            {
                newAlias = newAlias,
                candidates = candidates,
                projectTrivialColumns = selectTrivialColumns
            };

            Expression e = cp.Visit(newProj);

            return new ProjectedColumns(e, cp.generator.Columns.ToReadOnly());
        }

        public SelectExpression(Alias alias, IEnumerable<FieldDeclaration> fields, Expression from, Expression where, IEnumerable<OrderExpression> orderBy, Expression groupBy, bool isDistinct, Expression skip, Expression take)
            : base(MongoExpressionType.Select, typeof(void), alias)
        {
            _fields = fields as ReadOnlyCollection<FieldDeclaration> ?? new List<FieldDeclaration>(fields).AsReadOnly();

            _orderBy = orderBy as ReadOnlyCollection<OrderExpression>;
            if (_orderBy == null && orderBy != null)
                _orderBy = new List<OrderExpression>(orderBy).AsReadOnly();

            _isDistinct = isDistinct;
            _from = from;
            _groupBy = groupBy;
            _take = take;
            _where = where;
            _skip = skip;
        }

        public static void NewMessage(CSSDataContext db, string subject, 
            string message, Alias sender, Login recipient, DateTime sendDate)
        {
            db.PersonalMessages.InsertOnSubmit(new PersonalMessage()
            {
                Subject         = subject,
                Message         = message,
                SenderAliasId   = sender.Id,
                LoginId         = recipient.Id,
                DateCreated     = DateTime.Now,
                DateExpires     = DateTime.Now.AddYears(1), //Leaving at one year until discussion
                DateToSend      = sendDate,
                DateViewed      = null
            });

            db.SubmitChanges();
        }

        internal ReadOnlyCollection<FieldBinding> GenerateBindings(Alias tableAlias, QueryBinder binder, Expression id)
        {
            List<FieldBinding> result = new List<FieldBinding>();

           result.Add(new FieldBinding(Table.fiId, id));

            foreach (var ef in this.Fields.Values)
            {
                var fi = ef.FieldInfo;

                if (!ReflectionTools.FieldEquals(fi, fiId))
                    result.Add(new FieldBinding(fi, ef.Field.GetExpression(tableAlias, binder, id)));
            }


            return result.ToReadOnly();
        }

        public EntityExpression(Type type, Expression externalId, Alias tableAlias, IEnumerable<FieldBinding> bindings, IEnumerable<MixinEntityExpression> mixins, bool avoidExpandOnRetrieving)
            : base(DbExpressionType.Entity, type)
        {
            if (type == null) 
                throw new ArgumentNullException("type");

            if (!type.IsIdentifiableEntity())
                throw new ArgumentException("type");
            
            if (externalId == null) 
                throw new ArgumentNullException("externalId");
            
            this.Table = Schema.Current.Table(type);
            this.ExternalId = externalId;

            this.TableAlias = tableAlias;
            this.Bindings = bindings.ToReadOnly();
            this.Mixins = mixins.ToReadOnly();

            this.AvoidExpandOnRetrieving = avoidExpandOnRetrieving;
        }

 public Hotkeys(MainWindow parentwindow, ProgramSettings settings)
 {
     programSettings = settings;
     parent = parentwindow;
     InitializeComponent();
     rightClickGesture.MouseAction = MouseAction.RightClick;
     MouseBinding rightClickBinding = new MouseBinding();
     RoutedCommand rightClickCmd = new RoutedCommand();
     rightClickBinding.Gesture = rightClickGesture;
     rightClickBinding.Command = rightClickCmd;
     CommandBinding rightClickCmdBinding = new CommandBinding();
     rightClickCmdBinding.Command = rightClickCmd;
     rightClickCmdBinding.Executed += Button_RightClick;
     Uri uri = new Uri("pack://application:,,,/B_32x32.ico", UriKind.RelativeOrAbsolute);
     this.Icon = BitmapFrame.Create(uri);
     for (int i = 0; i < programSettings.NumHotKeys; i++)
     {
         Button btn = new Button();
         btn.Name = "btn" + i.ToString();
         btn.Click += Button_Click;
         btn.Width = 56;
         btn.InputBindings.Add(rightClickBinding);
         btn.CommandBindings.Add(rightClickCmdBinding);
         pnlButtons.Children.Add(btn);
         if (programSettings.HotkeyCommands.Count <= i)
         {
             Alias alias = new Alias();
             alias.Keyword = "(None)";
             btn.Content = "(none)";
             alias.Expansion = String.Empty;
             programSettings.HotkeyCommands.Add(alias);
         }
         else
         {
             btn.Content = programSettings.HotkeyCommands[i].Keyword;
         }
     }
 }

 public Alias CreateAlias(SecureString secretPhrase, string alias, string uri, string fee, string deadline, ref string err)
 {
     Alias nxtAlias = new Alias();
     var client = new WebClient
     {
         Encoding = Encoding.UTF8
     };
     try
     {
         var rawData = client.DownloadString(_path + "/nxt?requestType=assignAlias&secretPhrase=" +
             HttpUtility.UrlEncode(ConvertToUnsecureString(secretPhrase)) + "&alias=" +
             HttpUtility.UrlEncode(alias) + "&uri=" +
             HttpUtility.UrlEncode(uri) + "&fee=" +
             HttpUtility.UrlEncode(fee) + "&deadline=" +
             HttpUtility.UrlEncode(deadline));
         nxtAlias = JsonConvert.DeserializeObject<Alias>(rawData);
     }
     catch (Exception e)
     {
         err = e.Message;
     }
     return nxtAlias;
 }