Пример #1
0
 public static String getMessageText(ExceptionMessage msg,params Object[] args)
 {
     String message;
     switch (msg) {
         case ExceptionMessage.ERROR_FILESYSTEM_NOTALLOW_SIZE:
             message = String.Format(Properties.Resources.ERROR_FILESYSTEM_NOTALLOW_SIZE, args);
             break;
         case ExceptionMessage.ERROR_MINIMUN_PART_SIZE:
             message = string.Format(Properties.Resources.ERROR_MINIMUN_PART_SIZE, args);
             break;
         case ExceptionMessage.ERROR_NO_SPACE_TO_SPLIT:
             message = Properties.Resources.ERROR_NO_SPACE_TO_SPLIT;
             break;
         case ExceptionMessage.ERROR_OPENING_FILE:
             message = String.Format(Properties.Resources.ERROR_OPENING_FILE, args);
             break;
         case ExceptionMessage.ERROR_TOTALSIZE_NOTEQUALS:
             message = Properties.Resources.ERROR_TOTALSIZE_NOTEQUALS;
             break;
         default:
             message = string.Empty;
             break;
     }
     return message;
 }
Пример #2
0
        public void Format_MessageIsException_InfoIsWrittenAfterDateInMessage()
        {
            var timeService = new FakeTimeService();
            var current = new DateTime(2012, 08, 28, 12, 0, 0);
            timeService.CurrentDateTime = current;
            var message = new ExceptionMessage();
            var formatter = new LogFormater(timeService);

            var formattedMessage = formatter.Format(message);

            Assert.IsTrue(formattedMessage.StartsWith("[28.08.2012 12:00][Exception]"));
        }
        public static void SendException(ExceptionMessage message)
        {
            if (!analyticsWebsiteConnected)
            {
                Connect();
            }

            if (analyticsWebsiteExceptionHubConnection.State == ConnectionState.Connected)
                analyticsWebsiteProxy.Invoke("SendException", message);
            else
            {
                Connect();
                analyticsWebsiteProxy.Invoke("SendException", message);
            }
        }
Пример #4
0
 public static MessageBoxIcon getMessageIcon(ExceptionMessage msg)
 {
     MessageBoxIcon icon;
     switch (msg) {
         case ExceptionMessage.ERROR_NO_SPACE_TO_SPLIT:
         case ExceptionMessage.ERROR_OPENING_FILE:
             icon = MessageBoxIcon.Hand;
             break;
         case ExceptionMessage.ERROR_FILESYSTEM_NOTALLOW_SIZE:
         case ExceptionMessage.ERROR_MINIMUN_PART_SIZE:
         case ExceptionMessage.ERROR_TOTALSIZE_NOTEQUALS:
             icon = MessageBoxIcon.Error;
             break;
         default:
             icon = MessageBoxIcon.Information;
             break;
     }
     return icon;
 }
        /// <summary>
        /// this method implements logic to save the graph to .grf file
        /// first line of file will have vertex info
        /// second line will have edges info
        /// third line will have commodities and their respective demands
        /// </summary>
        /// <param name="parameter"></param>
        private void _SaveGraph(object parameter)
        {
            int EdgeCount = Graph.EdgeCount;

            string[] txtArray = new string[3];
            foreach (NetVertex vx in Graph.Vertices)
            {
                txtArray[0] += vx.ID.ToString() + ",";
            }
            txtArray[0] = txtArray[0].TrimEnd(',');

            for (int i = 0; i < EdgeCount; i++)
            {
                txtArray[1] += Graph.Edges.ElementAt(i).Source.ID.ToString() + "-";
                txtArray[1] += Graph.Edges.ElementAt(i).Target.ID.ToString() + ",";
            }

            txtArray[1] = txtArray[1].TrimEnd(',');
            foreach (CommoditiesEntryViewModel cvm in CommodityList)
            {
                txtArray[2] += cvm.OriginID + "-" + cvm.DestinationID + "-" + cvm.DemandVal + ",";
            }
            txtArray[2] = txtArray[2].TrimEnd(',');
            try
            {
                SaveFileDialog saveDlg = new SaveFileDialog();
                saveDlg.Filter          = "Graph File |*.grf";
                saveDlg.FileName        = _openedFileName;
                saveDlg.OverwritePrompt = false;
                saveDlg.CheckFileExists = false;
                if (true == saveDlg.ShowDialog())
                {
                    File.WriteAllLines(saveDlg.FileName, txtArray);
                }
                _openedFileName = saveDlg.FileName;
            }
            catch (Exception ex)
            {
                ExceptionMessage.Show("Exception saving graph " + ex.ToString());
            }
        }
Пример #6
0
        /// <summary>コンストラクタ</summary>
        public ComplexConvolution1D(Shape inshape, Shape kernelshape, int stride, bool gradmode) :
            base(inputs: 2, outputs: 1, allow_resubstitution: false)
        {
            if (inshape.Type != ShapeType.Map || inshape.Ndim != 3)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(inshape, ("Ndim", 3), ("Type", ShapeType.Map)));
            }

            if (kernelshape.Type != ShapeType.Kernel || kernelshape.Ndim != 3)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(kernelshape, ("Ndim", 3), ("Type", ShapeType.Kernel)));
            }

            if (inshape.Channels % 2 != 0)
            {
                throw new AggregateException(ExceptionMessage.TensorLengthMultiple("Channels", inshape, inshape.Channels, 2));
            }

            if (kernelshape.InChannels % 2 != 0)
            {
                throw new AggregateException(ExceptionMessage.TensorLengthMultiple("InChannels", kernelshape, kernelshape.Channels, 2));
            }

            if (inshape.Channels != kernelshape.InChannels)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(kernelshape, ("InChannels", inshape.Channels)));
            }

            if (stride < 1)
            {
                throw new ArgumentException(nameof(stride));
            }

            int outwidth = (inshape.Width - kernelshape.Width) / stride + 1;

            this.InShape     = inshape;
            this.OutShape    = Shape.Map1D(kernelshape.OutChannels * 2, outwidth, inshape.Batch);
            this.KernelShape = kernelshape;
            this.Stride      = stride;
            this.GradMode    = gradmode;
        }
Пример #7
0
    public static Texture2D LoadPNG(string path)
    {
        try
        {
            // ファイルバッファ
            byte[] buf = oulFile.ReadAllBytes(path);

            // バイナリオープン
            //using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read))
            //using (BinaryReader reader = new BinaryReader(file))
            //{
            //    buf = reader.ReadBytes((int)reader.BaseStream.Length);

            // 16バイトから開始
            int pos = 16;

            // 画像幅計算
            int width = 0;
            for (int i = 0; i < 4; i++)
            {
                width = width * 256 + buf[pos++];
            }
            int height = 0;
            for (int i = 0; i < 4; i++)
            {
                height = height * 256 + buf[pos++];
            }

            // テクスチャ作成
            Texture2D texture = new Texture2D(width, height);
            texture.LoadImage(buf);

            return(texture);
        }
        catch (Exception e)
        {
            ExceptionMessage.Message("png load error!", e);
        }

        return(null);
    }
Пример #8
0
        public static async Task MainAsync(string[] args)
        {
            var dispatcher = ServiceProvider.GetService <IDispatcher>();

            // Command - Exception
            var createFaultedCustomerCommand = new CreateCustomer();
            var faultedResult = await dispatcher.Command(createFaultedCustomerCommand);

            // Command Create
            var createCustomerCommand = new CreateCustomer();

            createCustomerCommand.FirstName = "Louis";
            createCustomerCommand.LastName  = "Lewis";
            createCustomerCommand.UserName  = "******";

            var createResult = await dispatcher.Command(createCustomerCommand);

            var createdCustomerId = Guid.Parse(((CommandResult)createResult).RecordId);

            // Query Paged
            var queryPage        = new QueryPage();
            var queryPagedResult = await dispatcher.Query <QueryPage, GenericResultsList <CustomerLite> >(queryPage);

            // Query Single Lite
            var getCustomerQuery = new GetCustomer(id: createdCustomerId);
            var customerLite     = await dispatcher.Query <GetCustomer, CustomerLite>(getCustomerQuery);

            // Query Single Detail
            var customerDetail = await dispatcher.Query <GetCustomer, CustomerDetail>(getCustomerQuery);

            // Command Delete
            var deleteCommand = new DeleteCustomer(id: createdCustomerId);
            var deleteResult  = await dispatcher.Command(deleteCommand);

            // Message
            var exception        = new NotImplementedException("Lets throw an exception");
            var exceptionMessage = new ExceptionMessage {
                Exception = exception
            };
            await dispatcher.Message(exceptionMessage);
        }
        void Onrecebetarifa(object source, string tarifa)
        {
            if (tarifa == "Tarifa Simples")
            {
                try
                {
                    Model.CalculoElecSimples(ContagemVazio, ContagemFora);
                }

                catch (ErroConversaoRecebe)
                {
                    ExceptionMessage.Message(message);
                }
            }

            else if (tarifa == "Tarifa Bi-Horária")
            {
                try
                {
                    Model.CalculoElecBi(ContagemVazio, ContagemFora);
                }

                catch (ErroConversaoRecebe)
                {
                    ExceptionMessage.Message(message);
                }
            }

            else if (tarifa == "Tarifa Tri-Horária")
            {
                try
                {
                    Model.CalculoElecTri(ContagemVazio, ContagemFora);
                }

                catch (ErroConversaoRecebe)
                {
                    ExceptionMessage.Message(message);
                }
            }
        }
        /// <summary>コンストラクタ</summary>
        public TrivectorDeconvolution1D(Shape outshape, Shape kernelshape, int stride, bool gradmode) :
            base(inputs: 2, outputs: 1, allow_resubstitution: false)
        {
            if (outshape.Type != ShapeType.Map || outshape.Ndim != 3)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(outshape, ("Ndim", 3), ("Type", ShapeType.Map)));
            }

            if (kernelshape.Type != ShapeType.Kernel || kernelshape.Ndim != 3)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(kernelshape, ("Ndim", 3), ("Type", ShapeType.Kernel)));
            }

            if (outshape.Channels % 3 != 0)
            {
                throw new AggregateException(ExceptionMessage.TensorLengthMultiple("Channels", outshape, outshape.Channels, 3));
            }

            if (kernelshape.InChannels % 4 != 0)
            {
                throw new AggregateException(ExceptionMessage.TensorLengthMultiple("InChannels", kernelshape, kernelshape.Channels, 4));
            }

            if (outshape.Channels / 3 * 4 != kernelshape.InChannels)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(kernelshape, ("InChannels", outshape.Channels / 3 * 4)));
            }

            if (stride < 1)
            {
                throw new ArgumentException(nameof(stride));
            }

            int inwidth = (outshape.Width - kernelshape.Width) / stride + 1;

            this.InShape     = Shape.Map1D(kernelshape.OutChannels * 3, inwidth, outshape.Batch);
            this.OutShape    = outshape;
            this.KernelShape = kernelshape;
            this.Stride      = stride;
            this.GradMode    = gradmode;
        }
Пример #11
0
 /// <summary>
 ///     On save clicked
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void Save_Click(object sender, RoutedEventArgs e)
 {
     //update or save the tester
     try
     {
         _tester.Address = AddressTextBox.Address;
         if (_update)
         {
             _blimp.UpdateTester(_tester);
         }
         else
         {
             _blimp.AddTester(_tester);
         }
         Close();
     }
     catch (Exception ex)
     {
         ExceptionMessage.Show(ex.Message, ex.ToString());
     }
 }
Пример #12
0
        /// <summary>
        ///     On login click open tester window
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void TesterLoginButton_Click(object sender, EventArgs e)
        {
            try
            {
                Hide();
                //open window
                var win = new TesterWin(int.Parse(TesterIDTestBox.Text));
                win.ShowDialog();
                Show();

                //clean text boxes
                TesterIDTestBox.Text        = "";
                TesterIDTestBox.BorderBrush = Brushes.LightGray;
                TesterIDTestBox.Focus();
            }
            catch
            {
                ExceptionMessage.Show("Tester doesn't exist please contact the administrator.");
                Show();
            }
        }
Пример #13
0
        public void Validate_ODataRequestOptions_Throws_ODataException_If_ODataVersion_BelowMinSupported()
        {
            var odataRequestOptions = new ODataRequestOptions(
                new Uri("https://services.odata.org/OData"),
                ODataIsolationLevel.None,
                ODataMetadataLevel.Minimal,
                ODataVersion.Parse("3.0"), // symantically this makes no sense but the scenario is needed for the test case.
                ODataVersion.OData40);

            var odataServiceOptions = new ODataServiceOptions(
                ODataVersion.MinVersion,
                ODataVersion.MaxVersion,
                new[] { ODataIsolationLevel.None },
                new[] { "application/json" });

            ODataException odataException = Assert.Throws <ODataException>(() => odataServiceOptions.Validate(odataRequestOptions));

            Assert.Equal(ExceptionMessage.ODataVersionNotSupported(odataRequestOptions.ODataVersion, odataServiceOptions.MinVersion, odataServiceOptions.MaxVersion), odataException.Message);
            Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
            Assert.Equal(ODataRequestHeaderNames.ODataVersion, odataException.Target);
        }
Пример #14
0
        /// <summary>
        ///     On login Click open administrator window
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AdminLoginButton_Click(object sender, EventArgs e)
        {
            if (AdminUsernameTextBox.Text == Configuration.AdminUser &&
                AdminPasswordTextBox.Password == Configuration.AdminPassword)
            {
                //clean text boxes
                AdminUsernameTextBox.Text     = "";
                AdminPasswordTextBox.Password = "";

                AdminUsernameTextBox.Focus();
                Hide();
                //open window
                var win = new Administrator();
                win.ShowDialog();
                Show();
            }
            else
            {
                ExceptionMessage.Show("Wrong Password or UserName.");
            }
        }
Пример #15
0
 /// <summary>
 ///     Remove selected trainee
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void RemoveTestClick(object sender, RoutedEventArgs e)
 {
     try
     {
         var test = TestGrid.SelectedItem as Test;
         //validate delete
         if (!ValidationMessage.Show("Are you sure you want to delete test number " + test?.Id + " ?"))
         {
             return;
         }
         _bL.RemoveTest(test);
         RefreshData();
     }
     catch (Exception ex)
     {
         if (ex.Message != "Object reference not set to an instance of an object.")
         {
             ExceptionMessage.Show(ex.Message, ex.ToString());
         }
     }
 }
Пример #16
0
        public static MessageBoxIcon getMessageIcon(ExceptionMessage msg)
        {
            MessageBoxIcon icon;

            switch (msg)
            {
            case ExceptionMessage.ERROR_NO_SPACE_TO_SPLIT:
            case ExceptionMessage.ERROR_OPENING_FILE:
            case ExceptionMessage.ERROR_CREATING_FILE:
            case ExceptionMessage.ERROR_FILESYSTEM_NOTALLOW_SIZE:
            case ExceptionMessage.ERROR_MINIMUN_PART_SIZE:
            case ExceptionMessage.ERROR_TOTALSIZE_NOTEQUALS:
                icon = MessageBoxIcon.Error;
                break;

            default:
                icon = MessageBoxIcon.Information;
                break;
            }
            return(icon);
        }
Пример #17
0
        /// <summary>
        /// Called when exception happens in a GUI routine
        /// </summary>
        private void OnGuiUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
        {
            bool   userLevel;
            string message = ExceptionMessage.GetUserMessage(e.Exception, out userLevel);

            if (userLevel)
            {
                // TODO FIX NOW would really like to find the window with focus, and not always use the main window...
                MainWindow.Focus();
                MainWindow.StatusBar.LogError(message);
                e.Handled = true;
            }
            else
            {
                var feedbackSent = AppLog.SendFeedback("Unhandled Exception in GUI\r\n" + e.Exception.ToString(), true);
                var dialog       = new PerfView.Dialogs.UnhandledExceptionDialog(MainWindow, e.Exception, feedbackSent);
                var ret          = dialog.ShowDialog();
                // If it returns, it means that the user has opted to continue.
                e.Handled = true;
            }
        }
Пример #18
0
        public void Validate_ODataRequestOptions_Throws_ODataException_If_MetadataLevel_NotSupported()
        {
            var odataRequestOptions = new ODataRequestOptions(
                new Uri("https://services.odata.org/OData"),
                ODataIsolationLevel.None,
                ODataMetadataLevel.Full,
                ODataVersion.OData40,
                ODataVersion.OData40);

            var odataServiceOptions = new ODataServiceOptions(
                ODataVersion.MinVersion,
                ODataVersion.MaxVersion,
                new[] { ODataIsolationLevel.None },
                new[] { "application/json" });

            ODataException odataException = Assert.Throws <ODataException>(() => odataServiceOptions.Validate(odataRequestOptions));

            Assert.Equal(ExceptionMessage.ODataMetadataLevelNotSupported("full", new[] { "none", "minimal" }), odataException.Message);
            Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
            Assert.Equal("odata.metadata", odataException.Target);
        }
Пример #19
0
        public void Validate_ODataRequestOptions_Throws_ODataException_If_IsolationLevel_NotSupported()
        {
            var odataRequestOptions = new ODataRequestOptions(
                new Uri("https://services.odata.org/OData"),
                ODataIsolationLevel.Snapshot,
                ODataMetadataLevel.Minimal,
                ODataVersion.OData40,
                ODataVersion.OData40);

            var odataServiceOptions = new ODataServiceOptions(
                ODataVersion.MinVersion,
                ODataVersion.MaxVersion,
                new[] { ODataIsolationLevel.None },
                new[] { "application/json" });

            ODataException odataException = Assert.Throws <ODataException>(() => odataServiceOptions.Validate(odataRequestOptions));

            Assert.Equal(ExceptionMessage.ODataIsolationLevelNotSupported("Snapshot"), odataException.Message);
            Assert.Equal(HttpStatusCode.PreconditionFailed, odataException.StatusCode);
            Assert.Equal(ODataRequestHeaderNames.ODataIsolation, odataException.Target);
        }
Пример #20
0
        public void Validate_ODataRequestOptions_Throws_ODataException_If_ODataMaxVersion_AboveMaxSupported()
        {
            var odataRequestOptions = new ODataRequestOptions(
                new Uri("https://services.odata.org/OData"),
                ODataIsolationLevel.None,
                ODataMetadataLevel.Minimal,
                ODataVersion.OData40,
                ODataVersion.Parse("5.0"));

            var odataServiceOptions = new ODataServiceOptions(
                ODataVersion.MinVersion,
                ODataVersion.MaxVersion,
                new[] { ODataIsolationLevel.None },
                new[] { "application/json" });

            ODataException odataException = Assert.Throws <ODataException>(() => odataServiceOptions.Validate(odataRequestOptions));

            Assert.Equal(ExceptionMessage.ODataMaxVersionNotSupported(odataRequestOptions.ODataMaxVersion, odataServiceOptions.MinVersion, odataServiceOptions.MaxVersion), odataException.Message);
            Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
            Assert.Equal(ODataRequestHeaderNames.ODataMaxVersion, odataException.Target);
        }
 /// <summary>
 /// This method is called by NodeClickLogic if the mode is set to 1
 /// the method is called two times: when user clicks first node and when user clicks second node
 /// to create an edge between them.
 /// first time it only store the node ID, second time it check if there is already an edge between those
 /// node. If there is no edge then it will add new edge to the graph.
 /// </summary>
 /// <param name="NodeID"></param>
 private void _CreateEdge(int NodeID)
 {
     if (_Counter == 0)
     {
         _FistNodeID = NodeID;
         _Counter++;
     }
     else if (_Counter == 1)
     {
         int from = 0, to = 0;
         int count = Graph.VertexCount;
         _Mode    = 0;
         _Counter = 0;
         for (int i = 0; i < count; i++)
         {
             if (Graph.Vertices.ElementAt(i).ID == _FistNodeID)
             {
                 from = i;
             }
             if (Graph.Vertices.ElementAt(i).ID == NodeID)
             {
                 to = i;
             }
         }
         if (from != to)
         {
             try
             {
                 if (!Graph.ContainsEdge(Graph.Vertices.ElementAt(from), Graph.Vertices.ElementAt(to)))
                 {
                     _AddNewGraphEdge(Graph.Vertices.ElementAt(from), Graph.Vertices.ElementAt(to));
                 }
             }
             catch (Exception ex)
             {
                 ExceptionMessage.Show("Exception when creating edge: " + ex.ToString());
             }
         }
     }
 }
Пример #22
0
        /// <summary>收到数据流</summary>
        /// <param name="session"></param>
        /// <param name="stream"></param>
        protected virtual void OnReceive(ISocketSession session, Stream stream)
        {
            try
            {
                Process(stream, session, session.Remote);

                //// 如果还有剩下,写入数据流,供下次使用
                //if (stream.Position < stream.Length)
                //{
                //    var ms = new MemoryStream();
                //    stream.CopyTo(ms);
                //    ms.Position = 0;
                //    session.Stream = ms;
                //}
                //else
                //    session.Stream = null;
            }
            catch (Exception ex)
            {
                if (NetHelper.Debug)
                {
                    NetHelper.WriteLog(ex.ToString());
                }

                // 去掉内部异常,以免过大
                if (ex.InnerException != null)
                {
                    ex.SetValue("_innerException", null);
                }
                var msg = new ExceptionMessage()
                {
                    Value = ex
                };
                //session.Send(msg.GetStream());
                OnSend(msg.GetStream());

                //// 出错后清空数据流,避免连锁反应
                //session.Stream = null;
            }
        }
        private void _OpenNetworkXGraph()
        {
            string[] lines = null;
            // Create an open file dialog box and only show *.grf files.
            try
            {
                OpenFileDialog openDlg = new OpenFileDialog();
                openDlg.Filter = "Text File |*.doc;*.txt;*.grf";
                //read all lines of file
                if (true == openDlg.ShowDialog())
                {
                    lines = File.ReadAllLines(openDlg.FileName);

                    this._openedFileName = openDlg.FileName;
                    this._DrawGraphWithCommodities(lines);
                }
            }
            catch (IOException ex)
            {
                ExceptionMessage.Show("Could not open file\n" + ex.ToString());
            }
        }
Пример #24
0
    static public byte[] ReadAllBytes(string path)
    {
        try
        {
            byte[] buf;
            // バイナリオープン
            using (FileStream file = new System.IO.FileStream(path, FileMode.Open, FileAccess.Read))
                using (BinaryReader reader = new System.IO.BinaryReader(file))
                {
                    buf = reader.ReadBytes((int)reader.BaseStream.Length);
                }

            return(buf);
        }

        catch (System.Exception e)
        {
            ExceptionMessage.Message("file error", e);
        }

        return(null);
    }
Пример #25
0
        public override void CheckInputShapes(params Shape[] inshapes)
        {
            base.CheckInputShapes(inshapes);

            if (inshapes[0].Ndim <= 0)
            {
                throw new ArgumentException(ExceptionMessage.Shape("Ndim", inshapes[0]));
            }

            if (inshapes[0] != inshapes[1])
            {
                throw new ArgumentException(ExceptionMessage.Shape(inshapes[1], inshapes[0]));
            }
            if (inshapes[0] != inshapes[2])
            {
                throw new ArgumentException(ExceptionMessage.Shape(inshapes[2], inshapes[0]));
            }
            if (inshapes[0] != inshapes[3])
            {
                throw new ArgumentException(ExceptionMessage.Shape(inshapes[3], inshapes[0]));
            }
        }
Пример #26
0
        public virtual MainViewModel <T> SearchDetail(T SearchContext)
        {
            var message = new ExceptionMessage("Enter->" + MethodBase.GetCurrentMethod());
            T   results = null;

            if (NotValidIdentity())
            {
                SessionExpired(message);
            }
            else
            {
                try
                {
                    results = GetRecordDetail(SearchContext, message);
                }
                catch (Exception ex)
                {
                    LogBaseControllerMessage(ex, message);
                }
            }
            return(new MainViewModel <T>(results, message));
        }
Пример #27
0
        /// <summary>形状を調整する</summary>
        public static VariableNode AdjectShape(VariableNode node, Shape shape)
        {
            if (shape != node.Shape)
            {
                if (shape.Ndim == 0 && node.Shape.Ndim > 0)
                {
                    node = Sum(node, keepdims: false);
                }
                else if (shape.Ndim == 1 && node.Shape.Ndim > 1 && shape[0] == node.Shape[0])
                {
                    int[] axes = (new int[node.Shape.Ndim - 1]).Select((_, idx) => idx + 1).ToArray();

                    node = Sum(node, axes, keepdims: false);
                }
                else
                {
                    throw new ArgumentException(ExceptionMessage.Broadcast(node.Shape, shape));
                }
            }

            return(node);
        }
        /// <summary>コンストラクタ</summary>
        public QuaternionKernelProductDense(int inchannels, int outchannels, bool transpose = false, int batch = 1)
        {
            if (inchannels % 4 != 0)
            {
                throw new ArgumentException(ExceptionMessage.ArgumentMultiple(nameof(inchannels), inchannels, 4));
            }
            if (outchannels % 4 != 0)
            {
                throw new ArgumentException(ExceptionMessage.ArgumentMultiple(nameof(outchannels), outchannels, 4));
            }

            this.arguments = new List <(ArgumentType type, Shape shape)> {
                (ArgumentType.In, Shape.Map0D(inchannels, batch)),
                (ArgumentType.In, Shape.Map0D(outchannels, batch)),
                (ArgumentType.Out, Shape.Kernel0D(inchannels, outchannels / 4))
            };

            this.InChannels  = inchannels;
            this.OutChannels = outchannels;
            this.Transpose   = transpose;
            this.Batch       = batch;
        }
Пример #29
0
        /// <summary>コンストラクタ</summary>
        public ComplexDense(int inchannels, int outchannels, bool gradmode = false, int batch = 1)
        {
            if (inchannels % 2 != 0)
            {
                throw new ArgumentException(ExceptionMessage.ArgumentMultiple(nameof(inchannels), inchannels, 2));
            }
            if (outchannels % 2 != 0)
            {
                throw new ArgumentException(ExceptionMessage.ArgumentMultiple(nameof(outchannels), outchannels, 2));
            }

            this.arguments = new List <(ArgumentType type, Shape shape)> {
                (ArgumentType.In, Shape.Map0D(inchannels, batch)),
                (ArgumentType.In, Shape.Kernel0D(inchannels, outchannels / 2)),
                (ArgumentType.Out, Shape.Map0D(outchannels, batch)),
            };

            this.InChannels  = inchannels;
            this.OutChannels = outchannels;
            this.GradMode    = gradmode;
            this.Batch       = batch;
        }
Пример #30
0
        private async Task HandleUnhandledExceptionAsync(HttpContext context,
                                                         Exception exception)
        {
            //_logger.LogError(exception, exception.Message);

            if (!context.Response.HasStarted)
            {
                int    statusCode = (int)HttpStatusCode.InternalServerError; // 500
                string message    = string.Empty;
#if DEBUG
                message = exception.Message;
#else
                message = "An unhandled exception has occurred";
#endif
                context.Response.Clear();
                context.Response.ContentType = "application/json";
                context.Response.StatusCode  = statusCode;

                var result = new ExceptionMessage(message).ToString();
                await context.Response.WriteAsync(result);
            }
        }
        public override int GetHashCode()
        {
            int hash = 1;

            if (user_ != null)
            {
                hash ^= User.GetHashCode();
            }
            if (ExceptionMessage.Length != 0)
            {
                hash ^= ExceptionMessage.GetHashCode();
            }
            if (ExceptionId.Length != 0)
            {
                hash ^= ExceptionId.GetHashCode();
            }
            if (JWToken.Length != 0)
            {
                hash ^= JWToken.GetHashCode();
            }
            return(hash);
        }
Пример #32
0
        /// <summary>コンストラクタ</summary>
        public PointwiseConvolution(Shape inshape, Shape kernelshape) :
            base(inputs: 2, outputs: 1, allow_resubstitution: false)
        {
            if (inshape.Type != ShapeType.Map || inshape.Ndim != 4)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(inshape, ("Ndim", 4), ("Type", ShapeType.Map)));
            }

            if (kernelshape.Type != ShapeType.Kernel || kernelshape.Ndim != 2)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(kernelshape, ("Ndim", 2), ("Type", ShapeType.Kernel)));
            }

            if (inshape.Channels != kernelshape.InChannels)
            {
                throw new ArgumentException(ExceptionMessage.TensorElements(kernelshape, ("InChannels", inshape.Channels)));
            }

            this.InShape     = inshape;
            this.OutShape    = Shape.Map2D(kernelshape.OutChannels, inshape.Width, inshape.Height, inshape.Batch);
            this.KernelShape = kernelshape;
        }
Пример #33
0
 /// <summary>
 ///     Remove selected trainee
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void RemoveTraineeClick(object sender, RoutedEventArgs e)
 {
     try
     {
         var trainee = TraineeGrid.SelectedItem as Trainee;
         //validate delete
         if (!ValidationMessage.Show("Are you sure you want to delete " + trainee?.FirstName + " " +
                                     trainee?.LastName + "?"))
         {
             return;
         }
         _bL.RemoveTrainee(trainee);
         RefreshData();
     }
     catch (Exception ex)
     {
         if (ex.Message != "Object reference not set to an instance of an object.")
         {
             ExceptionMessage.Show(ex.Message, ex.ToString());
         }
     }
 }
Пример #34
0
        /// <summary>
        /// 发生异常事件
        /// </summary>
        /// <param name="context">方法元数据</param>
        /// <param name="exception">异常实例</param>
        protected virtual void OnException(MethodAdviceContext context, Exception exception)
        {
            if (!context.TargetMethod.IsDefined(typeof(SkipExceptionAttribute), true))
            {
                //初始化异常日志
                this._exceptionLog.BuildBasicInfo(context);
                this._exceptionLog.BuildMethodArgsInfo(context);
                this._exceptionLog.BuildExceptionInfo(exception);

                //无需事务
                using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
                {
                    //插入数据库
                    Guid newId = LogMediator.Write(this._exceptionLog);

                    scope.Complete();

                    //初始化异常消息
                    this._exceptionMessage = new ExceptionMessage(exception.Message, newId);
                }
            }
        }
Пример #35
0
 /// <summary>
 /// Launch Split Message event
 /// </summary>
 /// <param name="msg"></param>
 /// <param name="type"></param>
 private void onMessage(ExceptionMessage msg, params Object[] parameters)
 {
     if (message != null) {
         message(this, new MessageArgs(msg, parameters));
     }
 }
Пример #36
0
 public void SendException(ExceptionMessage exception)
 {
     Clients.All.displayException(exception);
 }
 public ExceptionBase(ExceptionMessage exceptionMessage)
     : base(exceptionMessage.ToString())
 {
 }
 public ExceptionBase(ExceptionMessage exceptionMessage, System.Exception innerException)
     : base(exceptionMessage.ToString(), innerException)
 {
 }
 public virtual void Log(ExceptionMessage msg)
 {
     Email email = CreateEmail();
     email.Body = msg.Value;
     ServiceManager.Get<IEmailService>().Send(email);
 }
Пример #40
0
 public virtual void Log(ExceptionMessage msg)
 {
     MessageBox.Show(msg.Value, "Logger", MessageBoxButtons.OK, MessageBoxIcon.Error);
 }
Пример #41
0
 public virtual void Log(ExceptionMessage msg)
 {
     Console.WriteLine(DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss EXCEPTION : ") + msg.Value);
 }
Пример #42
0
 private static void AddException(string exception)
 {
     var ex = new ExceptionMessage(exception);
     if (!Exceptions.Contains(ex))
     {
         Exceptions.Add(ex);
     }
     else
     {
         var oldEx = Exceptions.IndexOf(ex);
         if (oldEx >= 0)
         {
             ex.Count += Exceptions[oldEx].Count;
             Exceptions.RemoveAt(oldEx);
         }
         Exceptions.Add(ex);
     }
 }
Пример #43
0
 /// <summary>
 /// Constructor for the message
 /// </summary>
 /// <param name="message"></param>
 /// <param name="type"></param>
 public MessageArgs(ExceptionMessage message, Object[] parameters)
 {
     this.Message = message;
     this.Parameters = parameters;
 }
Пример #44
0
 public bool Equals(ExceptionMessage other)
 {
     return string.Equals(Message, other.Message);
 }
 public void SetContent(ExceptionMessage message)
 {
     Message.text = message.Message + " (" + message.Count + ")" ;
     Date.text = message.Occurance.ToString();
 }
Пример #46
0
 public string GetBacktrace(ExceptionMessage e) {
   var q = from pair in e.DataList
           where pair.Key == "backtrace"
           select pair.Value;
   return (q.FirstOrDefault() ?? string.Empty);
 }
Пример #47
0
        static void Main(string[] args)
        {
            Random randomCountry = new Random();
            var bus = Configure.With()
                .Log4Net()
                .DefaultBuilder()
                .MsmqTransport()
                .MsmqSubscriptionStorage()
                .XmlSerializer()
                .DisableRavenInstall()
                .DisableTimeoutManager()
                .UnicastBus()
                .SendOnly();

            Console.WriteLine("Please select an option:");
            Console.WriteLine("Type 1: For exception testing");
            Console.WriteLine("Type 2: For admin testing");

            while (true)
            {
                string line = Console.ReadLine();

                if (line == "exit")
                {
                    break;
                }
                if (line == "1")
                {
                    try
                    {
                        throw new ArgumentException("Some exception happened!" + line);
                    }
                    catch (Exception exception)
                    {
                        var message = new ExceptionMessage()
                            {
                                Message = exception.Message,
                                Country = (Country) randomCountry.Next(0, 3),
                                //Country = Country.Uk,
                                StackTrace = exception.StackTrace,
                                TimeOccurred = DateTime.Now,
                                Type = (ExceptionType) randomCountry.Next(0, 2),
                            };
                        bus.Send(message);
                    }
                }
                if (line == "2")
                {
                    Console.WriteLine("Enter test message");
                    var message = Console.ReadLine();
                    var adminMessage = new AdminNotificationMessage()
                        {
                            Country = Country.Uk,
                            Message = message,
                            TimeOccurred = DateTime.Now,
                            Type = NotificationType.Verification
                        };
                    bus.Send(adminMessage);
                }
            }
        }
Пример #48
0
 public void Log(ExceptionMessage msg)
 {
     UdpPaperTrail.SendUdpMessage("<22>" + DateTime.Now.ToString("MMM d H:mm:ss") + key.Spaced() + ": " + msg.Value);
 }