MonoRail/TestSiteBrail/Controllers/AsyncController.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace TestSiteBrail.Controllers
  16 {
  17         using System;
  18         using Castle.MonoRail.Framework;
  19
  20         [Layout("master")]
  21         public class AsyncController : SmartDispatcherController
  22         {
  23                 #region Delegates
  24
  25                 public delegate string Output();
  26
  27                 #endregion
  28
  29                 private Output output;
  30
  31
  32                 public IAsyncResult BeginWithParams(int id, string name)
  33                 {
  34                         PropertyBag["id"] = id;
  35                         PropertyBag["name"] = name;
  36                         return CallAsync();
  37                 }
  38
  39                 public void EndWithParams()
  40                 {
  41                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
  42                 }
  43
  44
  45                 public IAsyncResult BeginIndex()
  46                 {
  47                         return CallAsync();
  48                 }
  49
  50                 public void EndIndex()
  51                 {
  52                         string s = output.EndInvoke(ControllerContext.Async.Result);
  53                         RenderText(s);
  54                 }
  55
  56                 public IAsyncResult BeginWithView()
  57                 {
  58                         return CallAsync();
  59                 }
  60
  61                 public void EndWithView()
  62                 {
  63                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
  64                 }
  65
  66                 public IAsyncResult BeginWithViewAndLayout()
  67                 {
  68                         return CallAsync();
  69                 }
  70
  71                 public void EndWithViewAndLayout()
  72                 {
  73                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
  74                 }
  75
  76                 public IAsyncResult BeginErrorBegin()
  77                 {
  78                         throw new InvalidCastException("test error on begin");
  79                 }
  80
  81                 public void EndErrorBegin()
  82                 {
  83                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
  84                 }
  85
  86
  87                 public IAsyncResult BeginErrorAsync()
  88                 {
  89                         return CallThrowingAsync();
  90                 }
  91
  92                 public void EndErrorAsync()
  93                 {
  94                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
  95                 }
  96
  97
  98                 public IAsyncResult BeginErrorEnd()
  99                 {
 100                         return CallAsync();
 101                 }
 102
 103                 public void EndErrorEnd()
 104                 {
 105                         throw new InvalidOperationException("test error from end");
 106                 }
 107
 108                 public IAsyncResult BeginWithRescueAsync()
 109                 {
 110                         return CallThrowingAsync();
 111                 }
 112
 113
 114                 [Rescue("UpdateErrorMsg")]
 115                 public void EndWithRescueAsync()
 116                 {
 117                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
 118                 }
 119
 120                 [Rescue("UpdateErrorMsg")]
 121                 public IAsyncResult BeginWithRescueBegin()
 122                 {
 123                         throw new InvalidCastException("test error on rescue");
 124                 }
 125
 126                 public void EndWithRescueBegin()
 127                 {
 128                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
 129                 }
 130
 131                 public IAsyncResult BeginWithRescueEnd()
 132                 {
 133                         return CallAsync();
 134                 }
 135
 136                 [Rescue("UpdateErrorMsg")]
 137                 public void EndWithRescueEnd()
 138                 {
 139                         throw new InvalidCastException("error from end");
 140                 }
 141
 142                 public IAsyncResult BeginWithActionLayout()
 143                 {
 144                         return CallAsync();
 145                 }
 146
 147                 [Layout("defaultlayout")]
 148                 public void EndWithActionLayout()
 149                 {
 150                         PropertyBag["value"] = output.EndInvoke(ControllerContext.Async.Result);
 151                 }
 152
 153                 [Rescue("UpdateErrorMsg")]
 154                 [Layout("defaultlayout")]
 155                 public IAsyncResult BeginRescueOnBeginActionLayout()
 156                 {
 157                         throw new InvalidOperationException("blah");
 158                 }
 159
 160                 public void EndRescueOnBeginActionLayout()
 161                 {
 162                 }
 163
 164                 private IAsyncResult CallThrowingAsync()
 165                 {
 166                         output = Throw;
 167                         return output.BeginInvoke(ControllerContext.Async.Callback, ControllerContext.Async.State);
 168                 }
 169
 170                 private string Throw()
 171                 {
 172                         throw new InvalidOperationException("error from async");
 173                 }
 174
 175                 private IAsyncResult CallAsync()
 176                 {
 177                         output = GetString;
 178                         return output.BeginInvoke(
 179                                 ControllerContext.Async.Callback,
 180                                 ControllerContext.Async.State);
 181                 }
 182
 183                 public string GetString()
 184                 {
 185                         return "value from async task";
 186                 }
 187         }
 188 }